algebra.modeq ⟷ Mathlib.Algebra.ModEq

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

@@ -426,7 +426,7 @@ theorem intCast_modEq_intCast {a b z : ℤ} : a ≡ b [PMOD (z : α)] ↔ a ≡
 @[simp, norm_cast]
 theorem natCast_modEq_natCast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [MOD n] := by
   simp_rw [← Int.natCast_modEq_iff, ← modeq_iff_int_modeq, ← @int_cast_modeq_int_cast α,
-    Int.cast_ofNat]
+    Int.cast_natCast]
 #align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.natCast_modEq_natCast
 -/
 

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

@@ -3,7 +3,7 @@ Copyright (c) 2023 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
-import Data.Int.Modeq
+import Data.Int.ModEq
 import GroupTheory.QuotientGroup
 
 #align_import algebra.modeq from "leanprover-community/mathlib"@"6cf5900728239efa287df7761ec2a1ac9cf39b29"
@@ -194,7 +194,7 @@ protected theorem of_zsmul : a ≡ b [PMOD z • p] → a ≡ b [PMOD p] := fun
 
 #print AddCommGroup.ModEq.of_nsmul /-
 protected theorem of_nsmul : a ≡ b [PMOD n • p] → a ≡ b [PMOD p] := fun ⟨m, hm⟩ =>
-  ⟨m * n, by rwa [mul_smul, coe_nat_zsmul]⟩
+  ⟨m * n, by rwa [mul_smul, natCast_zsmul]⟩
 #align add_comm_group.modeq.of_nsmul AddCommGroup.ModEq.of_nsmul
 -/
 
@@ -425,7 +425,7 @@ theorem intCast_modEq_intCast {a b z : ℤ} : a ≡ b [PMOD (z : α)] ↔ a ≡
 #print AddCommGroup.natCast_modEq_natCast /-
 @[simp, norm_cast]
 theorem natCast_modEq_natCast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [MOD n] := by
-  simp_rw [← Int.coe_nat_modEq_iff, ← modeq_iff_int_modeq, ← @int_cast_modeq_int_cast α,
+  simp_rw [← Int.natCast_modEq_iff, ← modeq_iff_int_modeq, ← @int_cast_modeq_int_cast α,
     Int.cast_ofNat]
 #align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.natCast_modEq_natCast
 -/

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

@@ -415,28 +415,28 @@ section AddCommGroupWithOne
 
 variable [AddCommGroupWithOne α] [CharZero α]
 
-#print AddCommGroup.int_cast_modEq_int_cast /-
+#print AddCommGroup.intCast_modEq_intCast /-
 @[simp, norm_cast]
-theorem int_cast_modEq_int_cast {a b z : ℤ} : a ≡ b [PMOD (z : α)] ↔ a ≡ b [PMOD z] := by
+theorem intCast_modEq_intCast {a b z : ℤ} : a ≡ b [PMOD (z : α)] ↔ a ≡ b [PMOD z] := by
   simp_rw [modeq, ← Int.cast_mul_eq_zsmul_cast] <;> norm_cast
-#align add_comm_group.int_cast_modeq_int_cast AddCommGroup.int_cast_modEq_int_cast
+#align add_comm_group.int_cast_modeq_int_cast AddCommGroup.intCast_modEq_intCast
 -/
 
-#print AddCommGroup.nat_cast_modEq_nat_cast /-
+#print AddCommGroup.natCast_modEq_natCast /-
 @[simp, norm_cast]
-theorem nat_cast_modEq_nat_cast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [MOD n] := by
+theorem natCast_modEq_natCast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [MOD n] := by
   simp_rw [← Int.coe_nat_modEq_iff, ← modeq_iff_int_modeq, ← @int_cast_modeq_int_cast α,
     Int.cast_ofNat]
-#align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.nat_cast_modEq_nat_cast
+#align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.natCast_modEq_natCast
 -/
 
 alias ⟨modeq.of_int_cast, modeq.int_cast⟩ := int_cast_modeq_int_cast
-#align add_comm_group.modeq.of_int_cast AddCommGroup.ModEq.of_int_cast
-#align add_comm_group.modeq.int_cast AddCommGroup.ModEq.int_cast
+#align add_comm_group.modeq.of_int_cast AddCommGroup.ModEq.of_intCast
+#align add_comm_group.modeq.int_cast AddCommGroup.ModEq.intCast
 
 alias ⟨_root_.nat.modeq.of_nat_cast, modeq.nat_cast⟩ := nat_cast_modeq_nat_cast
-#align nat.modeq.of_nat_cast Nat.ModEq.of_nat_cast
-#align add_comm_group.modeq.nat_cast AddCommGroup.ModEq.nat_cast
+#align nat.modeq.of_nat_cast Nat.ModEq.of_natCast
+#align add_comm_group.modeq.nat_cast AddCommGroup.ModEq.natCast
 
 end AddCommGroupWithOne
 

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

@@ -3,8 +3,8 @@ Copyright (c) 2023 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
-import Mathbin.Data.Int.Modeq
-import Mathbin.GroupTheory.QuotientGroup
+import Data.Int.Modeq
+import GroupTheory.QuotientGroup
 
 #align_import algebra.modeq from "leanprover-community/mathlib"@"6cf5900728239efa287df7761ec2a1ac9cf39b29"
 

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

@@ -73,7 +73,7 @@ theorem modEq_comm : a ≡ b [PMOD p] ↔ b ≡ a [PMOD p] :=
 #align add_comm_group.modeq_comm AddCommGroup.modEq_comm
 -/
 
-alias modeq_comm ↔ modeq.symm _
+alias ⟨modeq.symm, _⟩ := modeq_comm
 #align add_comm_group.modeq.symm AddCommGroup.ModEq.symm
 
 attribute [symm] modeq.symm
@@ -95,7 +95,7 @@ theorem neg_modEq_neg : -a ≡ -b [PMOD p] ↔ a ≡ b [PMOD p] :=
 #align add_comm_group.neg_modeq_neg AddCommGroup.neg_modEq_neg
 -/
 
-alias neg_modeq_neg ↔ modeq.of_neg modeq.neg
+alias ⟨modeq.of_neg, modeq.neg⟩ := neg_modeq_neg
 #align add_comm_group.modeq.of_neg AddCommGroup.ModEq.of_neg
 #align add_comm_group.modeq.neg AddCommGroup.ModEq.neg
 
@@ -106,7 +106,7 @@ theorem modEq_neg : a ≡ b [PMOD -p] ↔ a ≡ b [PMOD p] :=
 #align add_comm_group.modeq_neg AddCommGroup.modEq_neg
 -/
 
-alias modeq_neg ↔ modeq.of_neg' modeq.neg'
+alias ⟨modeq.of_neg', modeq.neg'⟩ := modeq_neg
 #align add_comm_group.modeq.of_neg' AddCommGroup.ModEq.of_neg'
 #align add_comm_group.modeq.neg' AddCommGroup.ModEq.neg'
 
@@ -228,10 +228,10 @@ theorem nsmul_modEq_nsmul [NoZeroSMulDivisors ℕ α] (hn : n ≠ 0) :
 #align add_comm_group.nsmul_modeq_nsmul AddCommGroup.nsmul_modEq_nsmul
 -/
 
-alias zsmul_modeq_zsmul ↔ modeq.zsmul_cancel _
+alias ⟨modeq.zsmul_cancel, _⟩ := zsmul_modeq_zsmul
 #align add_comm_group.modeq.zsmul_cancel AddCommGroup.ModEq.zsmul_cancel
 
-alias nsmul_modeq_nsmul ↔ modeq.nsmul_cancel _
+alias ⟨modeq.nsmul_cancel, _⟩ := nsmul_modeq_nsmul
 #align add_comm_group.modeq.nsmul_cancel AddCommGroup.ModEq.nsmul_cancel
 
 namespace Modeq
@@ -268,18 +268,18 @@ protected theorem sub_iff_right :
 #align add_comm_group.modeq.sub_iff_right AddCommGroup.ModEq.sub_iff_right
 -/
 
-alias modeq.add_iff_left ↔ add_left_cancel add
+alias ⟨add_left_cancel, add⟩ := modeq.add_iff_left
 #align add_comm_group.modeq.add_left_cancel AddCommGroup.ModEq.add_left_cancel
 #align add_comm_group.modeq.add AddCommGroup.ModEq.add
 
-alias modeq.add_iff_right ↔ add_right_cancel _
+alias ⟨add_right_cancel, _⟩ := modeq.add_iff_right
 #align add_comm_group.modeq.add_right_cancel AddCommGroup.ModEq.add_right_cancel
 
-alias modeq.sub_iff_left ↔ sub_left_cancel sub
+alias ⟨sub_left_cancel, sub⟩ := modeq.sub_iff_left
 #align add_comm_group.modeq.sub_left_cancel AddCommGroup.ModEq.sub_left_cancel
 #align add_comm_group.modeq.sub AddCommGroup.ModEq.sub
 
-alias modeq.sub_iff_right ↔ sub_right_cancel _
+alias ⟨sub_right_cancel, _⟩ := modeq.sub_iff_right
 #align add_comm_group.modeq.sub_right_cancel AddCommGroup.ModEq.sub_right_cancel
 
 attribute [protected] add_left_cancel add_right_cancel add sub_left_cancel sub_right_cancel sub
@@ -430,11 +430,11 @@ theorem nat_cast_modEq_nat_cast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a 
 #align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.nat_cast_modEq_nat_cast
 -/
 
-alias int_cast_modeq_int_cast ↔ modeq.of_int_cast modeq.int_cast
+alias ⟨modeq.of_int_cast, modeq.int_cast⟩ := int_cast_modeq_int_cast
 #align add_comm_group.modeq.of_int_cast AddCommGroup.ModEq.of_int_cast
 #align add_comm_group.modeq.int_cast AddCommGroup.ModEq.int_cast
 
-alias nat_cast_modeq_nat_cast ↔ _root_.nat.modeq.of_nat_cast modeq.nat_cast
+alias ⟨_root_.nat.modeq.of_nat_cast, modeq.nat_cast⟩ := nat_cast_modeq_nat_cast
 #align nat.modeq.of_nat_cast Nat.ModEq.of_nat_cast
 #align add_comm_group.modeq.nat_cast AddCommGroup.ModEq.nat_cast
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2023 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module algebra.modeq
-! leanprover-community/mathlib commit 6cf5900728239efa287df7761ec2a1ac9cf39b29
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Int.Modeq
 import Mathbin.GroupTheory.QuotientGroup
 
+#align_import algebra.modeq from "leanprover-community/mathlib"@"6cf5900728239efa287df7761ec2a1ac9cf39b29"
+
 /-!
 # Equality modulo an element
 

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

@@ -55,7 +55,6 @@ def ModEq (p a b : α) : Prop :=
 #align add_comm_group.modeq AddCommGroup.ModEq
 -/
 
--- mathport name: «expr ≡ [PMOD ]»
 notation:50 a " ≡ " b " [PMOD " p "]" => ModEq p a b
 
 #print AddCommGroup.modEq_refl /-
@@ -92,75 +91,103 @@ theorem ModEq.trans : a ≡ b [PMOD p] → b ≡ c [PMOD p] → a ≡ c [PMOD p]
 instance : IsRefl _ (ModEq p) :=
   ⟨modEq_refl⟩
 
+#print AddCommGroup.neg_modEq_neg /-
 @[simp]
 theorem neg_modEq_neg : -a ≡ -b [PMOD p] ↔ a ≡ b [PMOD p] :=
   modEq_comm.trans <| by simp [modeq]
 #align add_comm_group.neg_modeq_neg AddCommGroup.neg_modEq_neg
+-/
 
 alias neg_modeq_neg ↔ modeq.of_neg modeq.neg
 #align add_comm_group.modeq.of_neg AddCommGroup.ModEq.of_neg
 #align add_comm_group.modeq.neg AddCommGroup.ModEq.neg
 
+#print AddCommGroup.modEq_neg /-
 @[simp]
 theorem modEq_neg : a ≡ b [PMOD -p] ↔ a ≡ b [PMOD p] :=
   modEq_comm.trans <| by simp [modeq, ← neg_eq_iff_eq_neg]
 #align add_comm_group.modeq_neg AddCommGroup.modEq_neg
+-/
 
 alias modeq_neg ↔ modeq.of_neg' modeq.neg'
 #align add_comm_group.modeq.of_neg' AddCommGroup.ModEq.of_neg'
 #align add_comm_group.modeq.neg' AddCommGroup.ModEq.neg'
 
+#print AddCommGroup.modEq_sub /-
 theorem modEq_sub (a b : α) : a ≡ b [PMOD b - a] :=
   ⟨1, (one_smul _ _).symm⟩
 #align add_comm_group.modeq_sub AddCommGroup.modEq_sub
+-/
 
+#print AddCommGroup.modEq_zero /-
 @[simp]
 theorem modEq_zero : a ≡ b [PMOD 0] ↔ a = b := by simp [modeq, sub_eq_zero, eq_comm]
 #align add_comm_group.modeq_zero AddCommGroup.modEq_zero
+-/
 
+#print AddCommGroup.self_modEq_zero /-
 @[simp]
 theorem self_modEq_zero : p ≡ 0 [PMOD p] :=
   ⟨-1, by simp⟩
 #align add_comm_group.self_modeq_zero AddCommGroup.self_modEq_zero
+-/
 
+#print AddCommGroup.zsmul_modEq_zero /-
 @[simp]
 theorem zsmul_modEq_zero (z : ℤ) : z • p ≡ 0 [PMOD p] :=
   ⟨-z, by simp⟩
 #align add_comm_group.zsmul_modeq_zero AddCommGroup.zsmul_modEq_zero
+-/
 
+#print AddCommGroup.add_zsmul_modEq /-
 theorem add_zsmul_modEq (z : ℤ) : a + z • p ≡ a [PMOD p] :=
   ⟨-z, by simp⟩
 #align add_comm_group.add_zsmul_modeq AddCommGroup.add_zsmul_modEq
+-/
 
+#print AddCommGroup.zsmul_add_modEq /-
 theorem zsmul_add_modEq (z : ℤ) : z • p + a ≡ a [PMOD p] :=
   ⟨-z, by simp⟩
 #align add_comm_group.zsmul_add_modeq AddCommGroup.zsmul_add_modEq
+-/
 
+#print AddCommGroup.add_nsmul_modEq /-
 theorem add_nsmul_modEq (n : ℕ) : a + n • p ≡ a [PMOD p] :=
   ⟨-n, by simp⟩
 #align add_comm_group.add_nsmul_modeq AddCommGroup.add_nsmul_modEq
+-/
 
+#print AddCommGroup.nsmul_add_modEq /-
 theorem nsmul_add_modEq (n : ℕ) : n • p + a ≡ a [PMOD p] :=
   ⟨-n, by simp⟩
 #align add_comm_group.nsmul_add_modeq AddCommGroup.nsmul_add_modEq
+-/
 
 namespace Modeq
 
+#print AddCommGroup.ModEq.add_zsmul /-
 protected theorem add_zsmul (z : ℤ) : a ≡ b [PMOD p] → a + z • p ≡ b [PMOD p] :=
   (add_zsmul_modEq _).trans
 #align add_comm_group.modeq.add_zsmul AddCommGroup.ModEq.add_zsmul
+-/
 
+#print AddCommGroup.ModEq.zsmul_add /-
 protected theorem zsmul_add (z : ℤ) : a ≡ b [PMOD p] → z • p + a ≡ b [PMOD p] :=
   (zsmul_add_modEq _).trans
 #align add_comm_group.modeq.zsmul_add AddCommGroup.ModEq.zsmul_add
+-/
 
+#print AddCommGroup.ModEq.add_nsmul /-
 protected theorem add_nsmul (n : ℕ) : a ≡ b [PMOD p] → a + n • p ≡ b [PMOD p] :=
   (add_nsmul_modEq _).trans
 #align add_comm_group.modeq.add_nsmul AddCommGroup.ModEq.add_nsmul
+-/
 
+#print AddCommGroup.ModEq.nsmul_add /-
 protected theorem nsmul_add (n : ℕ) : a ≡ b [PMOD p] → n • p + a ≡ b [PMOD p] :=
   (nsmul_add_modEq _).trans
 #align add_comm_group.modeq.nsmul_add AddCommGroup.ModEq.nsmul_add
+-/
 
 #print AddCommGroup.ModEq.of_zsmul /-
 protected theorem of_zsmul : a ≡ b [PMOD z • p] → a ≡ b [PMOD p] := fun ⟨m, hm⟩ =>
@@ -188,17 +215,21 @@ protected theorem nsmul : a ≡ b [PMOD p] → n • a ≡ n • b [PMOD n • p
 
 end Modeq
 
+#print AddCommGroup.zsmul_modEq_zsmul /-
 @[simp]
 theorem zsmul_modEq_zsmul [NoZeroSMulDivisors ℤ α] (hn : z ≠ 0) :
     z • a ≡ z • b [PMOD z • p] ↔ a ≡ b [PMOD p] :=
   exists_congr fun m => by rw [← smul_sub, smul_comm, smul_right_inj hn] <;> infer_instance
 #align add_comm_group.zsmul_modeq_zsmul AddCommGroup.zsmul_modEq_zsmul
+-/
 
+#print AddCommGroup.nsmul_modEq_nsmul /-
 @[simp]
 theorem nsmul_modEq_nsmul [NoZeroSMulDivisors ℕ α] (hn : n ≠ 0) :
     n • a ≡ n • b [PMOD n • p] ↔ a ≡ b [PMOD p] :=
   exists_congr fun m => by rw [← smul_sub, smul_comm, smul_right_inj hn] <;> infer_instance
 #align add_comm_group.nsmul_modeq_nsmul AddCommGroup.nsmul_modEq_nsmul
+-/
 
 alias zsmul_modeq_zsmul ↔ modeq.zsmul_cancel _
 #align add_comm_group.modeq.zsmul_cancel AddCommGroup.ModEq.zsmul_cancel
@@ -208,29 +239,37 @@ alias nsmul_modeq_nsmul ↔ modeq.nsmul_cancel _
 
 namespace Modeq
 
+#print AddCommGroup.ModEq.add_iff_left /-
 @[simp]
 protected theorem add_iff_left :
     a₁ ≡ b₁ [PMOD p] → (a₁ + a₂ ≡ b₁ + b₂ [PMOD p] ↔ a₂ ≡ b₂ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.addLeft m).symm.exists_congr_left.trans <| by simpa [add_sub_add_comm, hm, add_smul]
 #align add_comm_group.modeq.add_iff_left AddCommGroup.ModEq.add_iff_left
+-/
 
+#print AddCommGroup.ModEq.add_iff_right /-
 @[simp]
 protected theorem add_iff_right :
     a₂ ≡ b₂ [PMOD p] → (a₁ + a₂ ≡ b₁ + b₂ [PMOD p] ↔ a₁ ≡ b₁ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.addRight m).symm.exists_congr_left.trans <| by simpa [add_sub_add_comm, hm, add_smul]
 #align add_comm_group.modeq.add_iff_right AddCommGroup.ModEq.add_iff_right
+-/
 
+#print AddCommGroup.ModEq.sub_iff_left /-
 @[simp]
 protected theorem sub_iff_left :
     a₁ ≡ b₁ [PMOD p] → (a₁ - a₂ ≡ b₁ - b₂ [PMOD p] ↔ a₂ ≡ b₂ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.subLeft m).symm.exists_congr_left.trans <| by simpa [sub_sub_sub_comm, hm, sub_smul]
 #align add_comm_group.modeq.sub_iff_left AddCommGroup.ModEq.sub_iff_left
+-/
 
+#print AddCommGroup.ModEq.sub_iff_right /-
 @[simp]
 protected theorem sub_iff_right :
     a₂ ≡ b₂ [PMOD p] → (a₁ - a₂ ≡ b₁ - b₂ [PMOD p] ↔ a₁ ≡ b₁ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.subRight m).symm.exists_congr_left.trans <| by simpa [sub_sub_sub_comm, hm, sub_smul]
 #align add_comm_group.modeq.sub_iff_right AddCommGroup.ModEq.sub_iff_right
+-/
 
 alias modeq.add_iff_left ↔ add_left_cancel add
 #align add_comm_group.modeq.add_left_cancel AddCommGroup.ModEq.add_left_cancel
@@ -248,75 +287,109 @@ alias modeq.sub_iff_right ↔ sub_right_cancel _
 
 attribute [protected] add_left_cancel add_right_cancel add sub_left_cancel sub_right_cancel sub
 
+#print AddCommGroup.ModEq.add_left /-
 protected theorem add_left (c : α) (h : a ≡ b [PMOD p]) : c + a ≡ c + b [PMOD p] :=
   modEq_rfl.add h
 #align add_comm_group.modeq.add_left AddCommGroup.ModEq.add_left
+-/
 
+#print AddCommGroup.ModEq.sub_left /-
 protected theorem sub_left (c : α) (h : a ≡ b [PMOD p]) : c - a ≡ c - b [PMOD p] :=
   modEq_rfl.sub h
 #align add_comm_group.modeq.sub_left AddCommGroup.ModEq.sub_left
+-/
 
+#print AddCommGroup.ModEq.add_right /-
 protected theorem add_right (c : α) (h : a ≡ b [PMOD p]) : a + c ≡ b + c [PMOD p] :=
   h.add modEq_rfl
 #align add_comm_group.modeq.add_right AddCommGroup.ModEq.add_right
+-/
 
+#print AddCommGroup.ModEq.sub_right /-
 protected theorem sub_right (c : α) (h : a ≡ b [PMOD p]) : a - c ≡ b - c [PMOD p] :=
   h.sub modEq_rfl
 #align add_comm_group.modeq.sub_right AddCommGroup.ModEq.sub_right
+-/
 
+#print AddCommGroup.ModEq.add_left_cancel' /-
 protected theorem add_left_cancel' (c : α) : c + a ≡ c + b [PMOD p] → a ≡ b [PMOD p] :=
   modEq_rfl.add_left_cancel
 #align add_comm_group.modeq.add_left_cancel' AddCommGroup.ModEq.add_left_cancel'
+-/
 
+#print AddCommGroup.ModEq.add_right_cancel' /-
 protected theorem add_right_cancel' (c : α) : a + c ≡ b + c [PMOD p] → a ≡ b [PMOD p] :=
   modEq_rfl.add_right_cancel
 #align add_comm_group.modeq.add_right_cancel' AddCommGroup.ModEq.add_right_cancel'
+-/
 
+#print AddCommGroup.ModEq.sub_left_cancel' /-
 protected theorem sub_left_cancel' (c : α) : c - a ≡ c - b [PMOD p] → a ≡ b [PMOD p] :=
   modEq_rfl.sub_left_cancel
 #align add_comm_group.modeq.sub_left_cancel' AddCommGroup.ModEq.sub_left_cancel'
+-/
 
+#print AddCommGroup.ModEq.sub_right_cancel' /-
 protected theorem sub_right_cancel' (c : α) : a - c ≡ b - c [PMOD p] → a ≡ b [PMOD p] :=
   modEq_rfl.sub_right_cancel
 #align add_comm_group.modeq.sub_right_cancel' AddCommGroup.ModEq.sub_right_cancel'
+-/
 
 end Modeq
 
+#print AddCommGroup.modEq_sub_iff_add_modEq' /-
 theorem modEq_sub_iff_add_modEq' : a ≡ b - c [PMOD p] ↔ c + a ≡ b [PMOD p] := by
   simp [modeq, sub_sub]
 #align add_comm_group.modeq_sub_iff_add_modeq' AddCommGroup.modEq_sub_iff_add_modEq'
+-/
 
+#print AddCommGroup.modEq_sub_iff_add_modEq /-
 theorem modEq_sub_iff_add_modEq : a ≡ b - c [PMOD p] ↔ a + c ≡ b [PMOD p] :=
   modEq_sub_iff_add_modEq'.trans <| by rw [add_comm]
 #align add_comm_group.modeq_sub_iff_add_modeq AddCommGroup.modEq_sub_iff_add_modEq
+-/
 
+#print AddCommGroup.sub_modEq_iff_modEq_add' /-
 theorem sub_modEq_iff_modEq_add' : a - b ≡ c [PMOD p] ↔ a ≡ b + c [PMOD p] :=
   modEq_comm.trans <| modEq_sub_iff_add_modEq'.trans modEq_comm
 #align add_comm_group.sub_modeq_iff_modeq_add' AddCommGroup.sub_modEq_iff_modEq_add'
+-/
 
+#print AddCommGroup.sub_modEq_iff_modEq_add /-
 theorem sub_modEq_iff_modEq_add : a - b ≡ c [PMOD p] ↔ a ≡ c + b [PMOD p] :=
   modEq_comm.trans <| modEq_sub_iff_add_modEq.trans modEq_comm
 #align add_comm_group.sub_modeq_iff_modeq_add AddCommGroup.sub_modEq_iff_modEq_add
+-/
 
+#print AddCommGroup.sub_modEq_zero /-
 @[simp]
 theorem sub_modEq_zero : a - b ≡ 0 [PMOD p] ↔ a ≡ b [PMOD p] := by simp [sub_modeq_iff_modeq_add]
 #align add_comm_group.sub_modeq_zero AddCommGroup.sub_modEq_zero
+-/
 
+#print AddCommGroup.add_modEq_left /-
 @[simp]
 theorem add_modEq_left : a + b ≡ a [PMOD p] ↔ b ≡ 0 [PMOD p] := by simp [← modeq_sub_iff_add_modeq']
 #align add_comm_group.add_modeq_left AddCommGroup.add_modEq_left
+-/
 
+#print AddCommGroup.add_modEq_right /-
 @[simp]
 theorem add_modEq_right : a + b ≡ b [PMOD p] ↔ a ≡ 0 [PMOD p] := by simp [← modeq_sub_iff_add_modeq]
 #align add_comm_group.add_modeq_right AddCommGroup.add_modEq_right
+-/
 
+#print AddCommGroup.modEq_iff_eq_add_zsmul /-
 theorem modEq_iff_eq_add_zsmul : a ≡ b [PMOD p] ↔ ∃ z : ℤ, b = a + z • p := by
   simp_rw [modeq, sub_eq_iff_eq_add']
 #align add_comm_group.modeq_iff_eq_add_zsmul AddCommGroup.modEq_iff_eq_add_zsmul
+-/
 
+#print AddCommGroup.not_modEq_iff_ne_add_zsmul /-
 theorem not_modEq_iff_ne_add_zsmul : ¬a ≡ b [PMOD p] ↔ ∀ z : ℤ, b ≠ a + z • p := by
   rw [modeq_iff_eq_add_zsmul, not_exists]
 #align add_comm_group.not_modeq_iff_ne_add_zsmul AddCommGroup.not_modEq_iff_ne_add_zsmul
+-/
 
 #print AddCommGroup.modEq_iff_eq_mod_zmultiples /-
 theorem modEq_iff_eq_mod_zmultiples : a ≡ b [PMOD p] ↔ (b : α ⧸ AddSubgroup.zmultiples p) = a := by
@@ -334,19 +407,23 @@ theorem not_modEq_iff_ne_mod_zmultiples :
 
 end AddCommGroup
 
+#print AddCommGroup.modEq_iff_int_modEq /-
 @[simp]
 theorem modEq_iff_int_modEq {a b z : ℤ} : a ≡ b [PMOD z] ↔ a ≡ b [ZMOD z] := by
   simp [modeq, dvd_iff_exists_eq_mul_left, Int.modEq_iff_dvd]
 #align add_comm_group.modeq_iff_int_modeq AddCommGroup.modEq_iff_int_modEq
+-/
 
 section AddCommGroupWithOne
 
 variable [AddCommGroupWithOne α] [CharZero α]
 
+#print AddCommGroup.int_cast_modEq_int_cast /-
 @[simp, norm_cast]
 theorem int_cast_modEq_int_cast {a b z : ℤ} : a ≡ b [PMOD (z : α)] ↔ a ≡ b [PMOD z] := by
   simp_rw [modeq, ← Int.cast_mul_eq_zsmul_cast] <;> norm_cast
 #align add_comm_group.int_cast_modeq_int_cast AddCommGroup.int_cast_modEq_int_cast
+-/
 
 #print AddCommGroup.nat_cast_modEq_nat_cast /-
 @[simp, norm_cast]

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

@@ -92,180 +92,72 @@ theorem ModEq.trans : a ≡ b [PMOD p] → b ≡ c [PMOD p] → a ≡ c [PMOD p]
 instance : IsRefl _ (ModEq p) :=
   ⟨modEq_refl⟩
 
-/- warning: add_comm_group.neg_modeq_neg -> AddCommGroup.neg_modEq_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) a) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) a) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.neg_modeq_neg AddCommGroup.neg_modEq_negₓ'. -/
 @[simp]
 theorem neg_modEq_neg : -a ≡ -b [PMOD p] ↔ a ≡ b [PMOD p] :=
   modEq_comm.trans <| by simp [modeq]
 #align add_comm_group.neg_modeq_neg AddCommGroup.neg_modEq_neg
 
-/- warning: add_comm_group.modeq.of_neg -> AddCommGroup.ModEq.of_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) a) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) a) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.of_neg AddCommGroup.ModEq.of_negₓ'. -/
-/- warning: add_comm_group.modeq.neg -> AddCommGroup.ModEq.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) a) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) a) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) b))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.neg AddCommGroup.ModEq.negₓ'. -/
 alias neg_modeq_neg ↔ modeq.of_neg modeq.neg
 #align add_comm_group.modeq.of_neg AddCommGroup.ModEq.of_neg
 #align add_comm_group.modeq.neg AddCommGroup.ModEq.neg
 
-/- warning: add_comm_group.modeq_neg -> AddCommGroup.modEq_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) p) a b) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) p) a b) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_neg AddCommGroup.modEq_negₓ'. -/
 @[simp]
 theorem modEq_neg : a ≡ b [PMOD -p] ↔ a ≡ b [PMOD p] :=
   modEq_comm.trans <| by simp [modeq, ← neg_eq_iff_eq_neg]
 #align add_comm_group.modeq_neg AddCommGroup.modEq_neg
 
-/- warning: add_comm_group.modeq.of_neg' -> AddCommGroup.ModEq.of_neg' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) p) a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) p) a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.of_neg' AddCommGroup.ModEq.of_neg'ₓ'. -/
-/- warning: add_comm_group.modeq.neg' -> AddCommGroup.ModEq.neg' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) p) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) p) a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.neg' AddCommGroup.ModEq.neg'ₓ'. -/
 alias modeq_neg ↔ modeq.of_neg' modeq.neg'
 #align add_comm_group.modeq.of_neg' AddCommGroup.ModEq.of_neg'
 #align add_comm_group.modeq.neg' AddCommGroup.ModEq.neg'
 
-/- warning: add_comm_group.modeq_sub -> AddCommGroup.modEq_sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] (a : α) (b : α), AddCommGroup.ModEq.{u1} α _inst_1 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b a) a b
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] (a : α) (b : α), AddCommGroup.ModEq.{u1} α _inst_1 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b a) a b
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_sub AddCommGroup.modEq_subₓ'. -/
 theorem modEq_sub (a b : α) : a ≡ b [PMOD b - a] :=
   ⟨1, (one_smul _ _).symm⟩
 #align add_comm_group.modeq_sub AddCommGroup.modEq_sub
 
-/- warning: add_comm_group.modeq_zero -> AddCommGroup.modEq_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))))) a b) (Eq.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))))) a b) (Eq.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_zero AddCommGroup.modEq_zeroₓ'. -/
 @[simp]
 theorem modEq_zero : a ≡ b [PMOD 0] ↔ a = b := by simp [modeq, sub_eq_zero, eq_comm]
 #align add_comm_group.modeq_zero AddCommGroup.modEq_zero
 
-/- warning: add_comm_group.self_modeq_zero -> AddCommGroup.self_modEq_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α}, AddCommGroup.ModEq.{u1} α _inst_1 p p (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α}, AddCommGroup.ModEq.{u1} α _inst_1 p p (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.self_modeq_zero AddCommGroup.self_modEq_zeroₓ'. -/
 @[simp]
 theorem self_modEq_zero : p ≡ 0 [PMOD p] :=
   ⟨-1, by simp⟩
 #align add_comm_group.self_modeq_zero AddCommGroup.self_modEq_zero
 
-/- warning: add_comm_group.zsmul_modeq_zero -> AddCommGroup.zsmul_modEq_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.zsmul_modeq_zero AddCommGroup.zsmul_modEq_zeroₓ'. -/
 @[simp]
 theorem zsmul_modEq_zero (z : ℤ) : z • p ≡ 0 [PMOD p] :=
   ⟨-z, by simp⟩
 #align add_comm_group.zsmul_modeq_zero AddCommGroup.zsmul_modEq_zero
 
-/- warning: add_comm_group.add_zsmul_modeq -> AddCommGroup.add_zsmul_modEq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p)) a
-Case conversion may be inaccurate. Consider using '#align add_comm_group.add_zsmul_modeq AddCommGroup.add_zsmul_modEqₓ'. -/
 theorem add_zsmul_modEq (z : ℤ) : a + z • p ≡ a [PMOD p] :=
   ⟨-z, by simp⟩
 #align add_comm_group.add_zsmul_modeq AddCommGroup.add_zsmul_modEq
 
-/- warning: add_comm_group.zsmul_add_modeq -> AddCommGroup.zsmul_add_modEq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p) a) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p) a) a
-Case conversion may be inaccurate. Consider using '#align add_comm_group.zsmul_add_modeq AddCommGroup.zsmul_add_modEqₓ'. -/
 theorem zsmul_add_modEq (z : ℤ) : z • p + a ≡ a [PMOD p] :=
   ⟨-z, by simp⟩
 #align add_comm_group.zsmul_add_modeq AddCommGroup.zsmul_add_modEq
 
-/- warning: add_comm_group.add_nsmul_modeq -> AddCommGroup.add_nsmul_modEq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (n : Nat), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (n : Nat), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p)) a
-Case conversion may be inaccurate. Consider using '#align add_comm_group.add_nsmul_modeq AddCommGroup.add_nsmul_modEqₓ'. -/
 theorem add_nsmul_modEq (n : ℕ) : a + n • p ≡ a [PMOD p] :=
   ⟨-n, by simp⟩
 #align add_comm_group.add_nsmul_modeq AddCommGroup.add_nsmul_modEq
 
-/- warning: add_comm_group.nsmul_add_modeq -> AddCommGroup.nsmul_add_modEq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (n : Nat), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p) a) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (n : Nat), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p) a) a
-Case conversion may be inaccurate. Consider using '#align add_comm_group.nsmul_add_modeq AddCommGroup.nsmul_add_modEqₓ'. -/
 theorem nsmul_add_modEq (n : ℕ) : n • p + a ≡ a [PMOD p] :=
   ⟨-n, by simp⟩
 #align add_comm_group.nsmul_add_modeq AddCommGroup.nsmul_add_modEq
 
 namespace Modeq
 
-/- warning: add_comm_group.modeq.add_zsmul -> AddCommGroup.ModEq.add_zsmul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (z : Int), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p)) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (z : Int), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p)) b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_zsmul AddCommGroup.ModEq.add_zsmulₓ'. -/
 protected theorem add_zsmul (z : ℤ) : a ≡ b [PMOD p] → a + z • p ≡ b [PMOD p] :=
   (add_zsmul_modEq _).trans
 #align add_comm_group.modeq.add_zsmul AddCommGroup.ModEq.add_zsmul
 
-/- warning: add_comm_group.modeq.zsmul_add -> AddCommGroup.ModEq.zsmul_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (z : Int), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p) a) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (z : Int), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p) a) b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.zsmul_add AddCommGroup.ModEq.zsmul_addₓ'. -/
 protected theorem zsmul_add (z : ℤ) : a ≡ b [PMOD p] → z • p + a ≡ b [PMOD p] :=
   (zsmul_add_modEq _).trans
 #align add_comm_group.modeq.zsmul_add AddCommGroup.ModEq.zsmul_add
 
-/- warning: add_comm_group.modeq.add_nsmul -> AddCommGroup.ModEq.add_nsmul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (n : Nat), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p)) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (n : Nat), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p)) b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_nsmul AddCommGroup.ModEq.add_nsmulₓ'. -/
 protected theorem add_nsmul (n : ℕ) : a ≡ b [PMOD p] → a + n • p ≡ b [PMOD p] :=
   (add_nsmul_modEq _).trans
 #align add_comm_group.modeq.add_nsmul AddCommGroup.ModEq.add_nsmul
 
-/- warning: add_comm_group.modeq.nsmul_add -> AddCommGroup.ModEq.nsmul_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (n : Nat), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p) a) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (n : Nat), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p) a) b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.nsmul_add AddCommGroup.ModEq.nsmul_addₓ'. -/
 protected theorem nsmul_add (n : ℕ) : a ≡ b [PMOD p] → n • p + a ≡ b [PMOD p] :=
   (nsmul_add_modEq _).trans
 #align add_comm_group.modeq.nsmul_add AddCommGroup.ModEq.nsmul_add
@@ -296,318 +188,132 @@ protected theorem nsmul : a ≡ b [PMOD p] → n • a ≡ n • b [PMOD n • p
 
 end Modeq
 
-/- warning: add_comm_group.zsmul_modeq_zsmul -> AddCommGroup.zsmul_modEq_zsmul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {z : Int} [_inst_2 : NoZeroSMulDivisors.{0, u1} Int α Int.hasZero (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))], (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z a) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {z : Int} [_inst_2 : NoZeroSMulDivisors.{0, u1} Int α (CommMonoidWithZero.toZero.{0} Int (CancelCommMonoidWithZero.toCommMonoidWithZero.{0} Int (IsDomain.toCancelCommMonoidWithZero.{0} Int Int.instCommSemiringInt (LinearOrderedRing.isDomain.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))], (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z a) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.zsmul_modeq_zsmul AddCommGroup.zsmul_modEq_zsmulₓ'. -/
 @[simp]
 theorem zsmul_modEq_zsmul [NoZeroSMulDivisors ℤ α] (hn : z ≠ 0) :
     z • a ≡ z • b [PMOD z • p] ↔ a ≡ b [PMOD p] :=
   exists_congr fun m => by rw [← smul_sub, smul_comm, smul_right_inj hn] <;> infer_instance
 #align add_comm_group.zsmul_modeq_zsmul AddCommGroup.zsmul_modEq_zsmul
 
-/- warning: add_comm_group.nsmul_modeq_nsmul -> AddCommGroup.nsmul_modEq_nsmul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {n : Nat} [_inst_2 : NoZeroSMulDivisors.{0, u1} Nat α Nat.hasZero (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))], (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n a) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {n : Nat} [_inst_2 : NoZeroSMulDivisors.{0, u1} Nat α (LinearOrderedCommMonoidWithZero.toZero.{0} Nat Nat.linearOrderedCommMonoidWithZero) (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))], (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n a) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.nsmul_modeq_nsmul AddCommGroup.nsmul_modEq_nsmulₓ'. -/
 @[simp]
 theorem nsmul_modEq_nsmul [NoZeroSMulDivisors ℕ α] (hn : n ≠ 0) :
     n • a ≡ n • b [PMOD n • p] ↔ a ≡ b [PMOD p] :=
   exists_congr fun m => by rw [← smul_sub, smul_comm, smul_right_inj hn] <;> infer_instance
 #align add_comm_group.nsmul_modeq_nsmul AddCommGroup.nsmul_modEq_nsmul
 
-/- warning: add_comm_group.modeq.zsmul_cancel -> AddCommGroup.ModEq.zsmul_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {z : Int} [_inst_2 : NoZeroSMulDivisors.{0, u1} Int α Int.hasZero (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))], (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))) -> (AddCommGroup.ModEq.{u1} α _inst_1 (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z a) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {z : Int} [_inst_2 : NoZeroSMulDivisors.{0, u1} Int α (CommMonoidWithZero.toZero.{0} Int (CancelCommMonoidWithZero.toCommMonoidWithZero.{0} Int (IsDomain.toCancelCommMonoidWithZero.{0} Int Int.instCommSemiringInt (LinearOrderedRing.isDomain.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))], (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))) -> (AddCommGroup.ModEq.{u1} α _inst_1 (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z a) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.zsmul_cancel AddCommGroup.ModEq.zsmul_cancelₓ'. -/
 alias zsmul_modeq_zsmul ↔ modeq.zsmul_cancel _
 #align add_comm_group.modeq.zsmul_cancel AddCommGroup.ModEq.zsmul_cancel
 
-/- warning: add_comm_group.modeq.nsmul_cancel -> AddCommGroup.ModEq.nsmul_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {n : Nat} [_inst_2 : NoZeroSMulDivisors.{0, u1} Nat α Nat.hasZero (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))], (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (AddCommGroup.ModEq.{u1} α _inst_1 (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n a) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {n : Nat} [_inst_2 : NoZeroSMulDivisors.{0, u1} Nat α (LinearOrderedCommMonoidWithZero.toZero.{0} Nat Nat.linearOrderedCommMonoidWithZero) (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))], (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (AddCommGroup.ModEq.{u1} α _inst_1 (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n a) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.nsmul_cancel AddCommGroup.ModEq.nsmul_cancelₓ'. -/
 alias nsmul_modeq_nsmul ↔ modeq.nsmul_cancel _
 #align add_comm_group.modeq.nsmul_cancel AddCommGroup.ModEq.nsmul_cancel
 
 namespace Modeq
 
-/- warning: add_comm_group.modeq.add_iff_left -> AddCommGroup.ModEq.add_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_iff_left AddCommGroup.ModEq.add_iff_leftₓ'. -/
 @[simp]
 protected theorem add_iff_left :
     a₁ ≡ b₁ [PMOD p] → (a₁ + a₂ ≡ b₁ + b₂ [PMOD p] ↔ a₂ ≡ b₂ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.addLeft m).symm.exists_congr_left.trans <| by simpa [add_sub_add_comm, hm, add_smul]
 #align add_comm_group.modeq.add_iff_left AddCommGroup.ModEq.add_iff_left
 
-/- warning: add_comm_group.modeq.add_iff_right -> AddCommGroup.ModEq.add_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_iff_right AddCommGroup.ModEq.add_iff_rightₓ'. -/
 @[simp]
 protected theorem add_iff_right :
     a₂ ≡ b₂ [PMOD p] → (a₁ + a₂ ≡ b₁ + b₂ [PMOD p] ↔ a₁ ≡ b₁ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.addRight m).symm.exists_congr_left.trans <| by simpa [add_sub_add_comm, hm, add_smul]
 #align add_comm_group.modeq.add_iff_right AddCommGroup.ModEq.add_iff_right
 
-/- warning: add_comm_group.modeq.sub_iff_left -> AddCommGroup.ModEq.sub_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_iff_left AddCommGroup.ModEq.sub_iff_leftₓ'. -/
 @[simp]
 protected theorem sub_iff_left :
     a₁ ≡ b₁ [PMOD p] → (a₁ - a₂ ≡ b₁ - b₂ [PMOD p] ↔ a₂ ≡ b₂ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.subLeft m).symm.exists_congr_left.trans <| by simpa [sub_sub_sub_comm, hm, sub_smul]
 #align add_comm_group.modeq.sub_iff_left AddCommGroup.ModEq.sub_iff_left
 
-/- warning: add_comm_group.modeq.sub_iff_right -> AddCommGroup.ModEq.sub_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_iff_right AddCommGroup.ModEq.sub_iff_rightₓ'. -/
 @[simp]
 protected theorem sub_iff_right :
     a₂ ≡ b₂ [PMOD p] → (a₁ - a₂ ≡ b₁ - b₂ [PMOD p] ↔ a₁ ≡ b₁ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.subRight m).symm.exists_congr_left.trans <| by simpa [sub_sub_sub_comm, hm, sub_smul]
 #align add_comm_group.modeq.sub_iff_right AddCommGroup.ModEq.sub_iff_right
 
-/- warning: add_comm_group.modeq.add_left_cancel -> AddCommGroup.ModEq.add_left_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_left_cancel AddCommGroup.ModEq.add_left_cancelₓ'. -/
-/- warning: add_comm_group.modeq.add -> AddCommGroup.ModEq.add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add AddCommGroup.ModEq.addₓ'. -/
 alias modeq.add_iff_left ↔ add_left_cancel add
 #align add_comm_group.modeq.add_left_cancel AddCommGroup.ModEq.add_left_cancel
 #align add_comm_group.modeq.add AddCommGroup.ModEq.add
 
-/- warning: add_comm_group.modeq.add_right_cancel -> AddCommGroup.ModEq.add_right_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_right_cancel AddCommGroup.ModEq.add_right_cancelₓ'. -/
 alias modeq.add_iff_right ↔ add_right_cancel _
 #align add_comm_group.modeq.add_right_cancel AddCommGroup.ModEq.add_right_cancel
 
-/- warning: add_comm_group.modeq.sub_left_cancel -> AddCommGroup.ModEq.sub_left_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_left_cancel AddCommGroup.ModEq.sub_left_cancelₓ'. -/
-/- warning: add_comm_group.modeq.sub -> AddCommGroup.ModEq.sub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub AddCommGroup.ModEq.subₓ'. -/
 alias modeq.sub_iff_left ↔ sub_left_cancel sub
 #align add_comm_group.modeq.sub_left_cancel AddCommGroup.ModEq.sub_left_cancel
 #align add_comm_group.modeq.sub AddCommGroup.ModEq.sub
 
-/- warning: add_comm_group.modeq.sub_right_cancel -> AddCommGroup.ModEq.sub_right_cancel is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_right_cancel AddCommGroup.ModEq.sub_right_cancelₓ'. -/
 alias modeq.sub_iff_right ↔ sub_right_cancel _
 #align add_comm_group.modeq.sub_right_cancel AddCommGroup.ModEq.sub_right_cancel
 
 attribute [protected] add_left_cancel add_right_cancel add sub_left_cancel sub_right_cancel sub
 
-/- warning: add_comm_group.modeq.add_left -> AddCommGroup.ModEq.add_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_left AddCommGroup.ModEq.add_leftₓ'. -/
 protected theorem add_left (c : α) (h : a ≡ b [PMOD p]) : c + a ≡ c + b [PMOD p] :=
   modEq_rfl.add h
 #align add_comm_group.modeq.add_left AddCommGroup.ModEq.add_left
 
-/- warning: add_comm_group.modeq.sub_left -> AddCommGroup.ModEq.sub_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c b))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_left AddCommGroup.ModEq.sub_leftₓ'. -/
 protected theorem sub_left (c : α) (h : a ≡ b [PMOD p]) : c - a ≡ c - b [PMOD p] :=
   modEq_rfl.sub h
 #align add_comm_group.modeq.sub_left AddCommGroup.ModEq.sub_left
 
-/- warning: add_comm_group.modeq.add_right -> AddCommGroup.ModEq.add_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_right AddCommGroup.ModEq.add_rightₓ'. -/
 protected theorem add_right (c : α) (h : a ≡ b [PMOD p]) : a + c ≡ b + c [PMOD p] :=
   h.add modEq_rfl
 #align add_comm_group.modeq.add_right AddCommGroup.ModEq.add_right
 
-/- warning: add_comm_group.modeq.sub_right -> AddCommGroup.ModEq.sub_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_right AddCommGroup.ModEq.sub_rightₓ'. -/
 protected theorem sub_right (c : α) (h : a ≡ b [PMOD p]) : a - c ≡ b - c [PMOD p] :=
   h.sub modEq_rfl
 #align add_comm_group.modeq.sub_right AddCommGroup.ModEq.sub_right
 
-/- warning: add_comm_group.modeq.add_left_cancel' -> AddCommGroup.ModEq.add_left_cancel' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_left_cancel' AddCommGroup.ModEq.add_left_cancel'ₓ'. -/
 protected theorem add_left_cancel' (c : α) : c + a ≡ c + b [PMOD p] → a ≡ b [PMOD p] :=
   modEq_rfl.add_left_cancel
 #align add_comm_group.modeq.add_left_cancel' AddCommGroup.ModEq.add_left_cancel'
 
-/- warning: add_comm_group.modeq.add_right_cancel' -> AddCommGroup.ModEq.add_right_cancel' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_right_cancel' AddCommGroup.ModEq.add_right_cancel'ₓ'. -/
 protected theorem add_right_cancel' (c : α) : a + c ≡ b + c [PMOD p] → a ≡ b [PMOD p] :=
   modEq_rfl.add_right_cancel
 #align add_comm_group.modeq.add_right_cancel' AddCommGroup.ModEq.add_right_cancel'
 
-/- warning: add_comm_group.modeq.sub_left_cancel' -> AddCommGroup.ModEq.sub_left_cancel' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_left_cancel' AddCommGroup.ModEq.sub_left_cancel'ₓ'. -/
 protected theorem sub_left_cancel' (c : α) : c - a ≡ c - b [PMOD p] → a ≡ b [PMOD p] :=
   modEq_rfl.sub_left_cancel
 #align add_comm_group.modeq.sub_left_cancel' AddCommGroup.ModEq.sub_left_cancel'
 
-/- warning: add_comm_group.modeq.sub_right_cancel' -> AddCommGroup.ModEq.sub_right_cancel' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_right_cancel' AddCommGroup.ModEq.sub_right_cancel'ₓ'. -/
 protected theorem sub_right_cancel' (c : α) : a - c ≡ b - c [PMOD p] → a ≡ b [PMOD p] :=
   modEq_rfl.sub_right_cancel
 #align add_comm_group.modeq.sub_right_cancel' AddCommGroup.ModEq.sub_right_cancel'
 
 end Modeq
 
-/- warning: add_comm_group.modeq_sub_iff_add_modeq' -> AddCommGroup.modEq_sub_iff_add_modEq' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_sub_iff_add_modeq' AddCommGroup.modEq_sub_iff_add_modEq'ₓ'. -/
 theorem modEq_sub_iff_add_modEq' : a ≡ b - c [PMOD p] ↔ c + a ≡ b [PMOD p] := by
   simp [modeq, sub_sub]
 #align add_comm_group.modeq_sub_iff_add_modeq' AddCommGroup.modEq_sub_iff_add_modEq'
 
-/- warning: add_comm_group.modeq_sub_iff_add_modeq -> AddCommGroup.modEq_sub_iff_add_modEq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_sub_iff_add_modeq AddCommGroup.modEq_sub_iff_add_modEqₓ'. -/
 theorem modEq_sub_iff_add_modEq : a ≡ b - c [PMOD p] ↔ a + c ≡ b [PMOD p] :=
   modEq_sub_iff_add_modEq'.trans <| by rw [add_comm]
 #align add_comm_group.modeq_sub_iff_add_modeq AddCommGroup.modEq_sub_iff_add_modEq
 
-/- warning: add_comm_group.sub_modeq_iff_modeq_add' -> AddCommGroup.sub_modEq_iff_modEq_add' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) (AddCommGroup.ModEq.{u1} α _inst_1 p a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) (AddCommGroup.ModEq.{u1} α _inst_1 p a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.sub_modeq_iff_modeq_add' AddCommGroup.sub_modEq_iff_modEq_add'ₓ'. -/
 theorem sub_modEq_iff_modEq_add' : a - b ≡ c [PMOD p] ↔ a ≡ b + c [PMOD p] :=
   modEq_comm.trans <| modEq_sub_iff_add_modEq'.trans modEq_comm
 #align add_comm_group.sub_modeq_iff_modeq_add' AddCommGroup.sub_modEq_iff_modEq_add'
 
-/- warning: add_comm_group.sub_modeq_iff_modeq_add -> AddCommGroup.sub_modEq_iff_modEq_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) (AddCommGroup.ModEq.{u1} α _inst_1 p a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) (AddCommGroup.ModEq.{u1} α _inst_1 p a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.sub_modeq_iff_modeq_add AddCommGroup.sub_modEq_iff_modEq_addₓ'. -/
 theorem sub_modEq_iff_modEq_add : a - b ≡ c [PMOD p] ↔ a ≡ c + b [PMOD p] :=
   modEq_comm.trans <| modEq_sub_iff_add_modEq.trans modEq_comm
 #align add_comm_group.sub_modeq_iff_modeq_add AddCommGroup.sub_modEq_iff_modEq_add
 
-/- warning: add_comm_group.sub_modeq_zero -> AddCommGroup.sub_modEq_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))))) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1)))))))) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.sub_modeq_zero AddCommGroup.sub_modEq_zeroₓ'. -/
 @[simp]
 theorem sub_modEq_zero : a - b ≡ 0 [PMOD p] ↔ a ≡ b [PMOD p] := by simp [sub_modeq_iff_modeq_add]
 #align add_comm_group.sub_modeq_zero AddCommGroup.sub_modEq_zero
 
-/- warning: add_comm_group.add_modeq_left -> AddCommGroup.add_modEq_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) a) (AddCommGroup.ModEq.{u1} α _inst_1 p b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) a) (AddCommGroup.ModEq.{u1} α _inst_1 p b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.add_modeq_left AddCommGroup.add_modEq_leftₓ'. -/
 @[simp]
 theorem add_modEq_left : a + b ≡ a [PMOD p] ↔ b ≡ 0 [PMOD p] := by simp [← modeq_sub_iff_add_modeq']
 #align add_comm_group.add_modeq_left AddCommGroup.add_modEq_left
 
-/- warning: add_comm_group.add_modeq_right -> AddCommGroup.add_modEq_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) b) (AddCommGroup.ModEq.{u1} α _inst_1 p a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) b) (AddCommGroup.ModEq.{u1} α _inst_1 p a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))))))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.add_modeq_right AddCommGroup.add_modEq_rightₓ'. -/
 @[simp]
 theorem add_modEq_right : a + b ≡ b [PMOD p] ↔ a ≡ 0 [PMOD p] := by simp [← modeq_sub_iff_add_modeq]
 #align add_comm_group.add_modeq_right AddCommGroup.add_modEq_right
 
-/- warning: add_comm_group.modeq_iff_eq_add_zsmul -> AddCommGroup.modEq_iff_eq_add_zsmul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a b) (Exists.{1} Int (fun (z : Int) => Eq.{succ u1} α b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a b) (Exists.{1} Int (fun (z : Int) => Eq.{succ u1} α b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p))))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_iff_eq_add_zsmul AddCommGroup.modEq_iff_eq_add_zsmulₓ'. -/
 theorem modEq_iff_eq_add_zsmul : a ≡ b [PMOD p] ↔ ∃ z : ℤ, b = a + z • p := by
   simp_rw [modeq, sub_eq_iff_eq_add']
 #align add_comm_group.modeq_iff_eq_add_zsmul AddCommGroup.modEq_iff_eq_add_zsmul
 
-/- warning: add_comm_group.not_modeq_iff_ne_add_zsmul -> AddCommGroup.not_modEq_iff_ne_add_zsmul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (Not (AddCommGroup.ModEq.{u1} α _inst_1 p a b)) (forall (z : Int), Ne.{succ u1} α b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (Not (AddCommGroup.ModEq.{u1} α _inst_1 p a b)) (forall (z : Int), Ne.{succ u1} α b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p)))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.not_modeq_iff_ne_add_zsmul AddCommGroup.not_modEq_iff_ne_add_zsmulₓ'. -/
 theorem not_modEq_iff_ne_add_zsmul : ¬a ≡ b [PMOD p] ↔ ∀ z : ℤ, b ≠ a + z • p := by
   rw [modeq_iff_eq_add_zsmul, not_exists]
 #align add_comm_group.not_modeq_iff_ne_add_zsmul AddCommGroup.not_modEq_iff_ne_add_zsmul
@@ -628,12 +334,6 @@ theorem not_modEq_iff_ne_mod_zmultiples :
 
 end AddCommGroup
 
-/- warning: add_comm_group.modeq_iff_int_modeq -> AddCommGroup.modEq_iff_int_modEq is a dubious translation:
-lean 3 declaration is
-  forall {a : Int} {b : Int} {z : Int}, Iff (AddCommGroup.ModEq.{0} Int Int.addCommGroup z a b) (Int.ModEq z a b)
-but is expected to have type
-  forall {a : Int} {b : Int} {z : Int}, Iff (AddCommGroup.ModEq.{0} Int Int.instAddCommGroupInt z a b) (Int.ModEq z a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_iff_int_modeq AddCommGroup.modEq_iff_int_modEqₓ'. -/
 @[simp]
 theorem modEq_iff_int_modEq {a b z : ℤ} : a ≡ b [PMOD z] ↔ a ≡ b [ZMOD z] := by
   simp [modeq, dvd_iff_exists_eq_mul_left, Int.modEq_iff_dvd]
@@ -643,12 +343,6 @@ section AddCommGroupWithOne
 
 variable [AddCommGroupWithOne α] [CharZero α]
 
-/- warning: add_comm_group.int_cast_modeq_int_cast -> AddCommGroup.int_cast_modEq_int_cast is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, Iff (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) z) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) a) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) b)) (AddCommGroup.ModEq.{0} Int Int.addCommGroup z a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, Iff (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) z) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) a) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) b)) (AddCommGroup.ModEq.{0} Int Int.instAddCommGroupInt z a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.int_cast_modeq_int_cast AddCommGroup.int_cast_modEq_int_castₓ'. -/
 @[simp, norm_cast]
 theorem int_cast_modEq_int_cast {a b z : ℤ} : a ≡ b [PMOD (z : α)] ↔ a ≡ b [PMOD z] := by
   simp_rw [modeq, ← Int.cast_mul_eq_zsmul_cast] <;> norm_cast
@@ -662,18 +356,6 @@ theorem nat_cast_modEq_nat_cast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a 
 #align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.nat_cast_modEq_nat_cast
 -/
 
-/- warning: add_comm_group.modeq.of_int_cast -> AddCommGroup.ModEq.of_int_cast is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) z) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) a) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) b)) -> (AddCommGroup.ModEq.{0} Int Int.addCommGroup z a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) z) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) a) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) b)) -> (AddCommGroup.ModEq.{0} Int Int.instAddCommGroupInt z a b)
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.of_int_cast AddCommGroup.ModEq.of_int_castₓ'. -/
-/- warning: add_comm_group.modeq.int_cast -> AddCommGroup.ModEq.int_cast is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, (AddCommGroup.ModEq.{0} Int Int.addCommGroup z a b) -> (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) z) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) a) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, (AddCommGroup.ModEq.{0} Int Int.instAddCommGroupInt z a b) -> (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) z) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) a) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) b))
-Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.int_cast AddCommGroup.ModEq.int_castₓ'. -/
 alias int_cast_modeq_int_cast ↔ modeq.of_int_cast modeq.int_cast
 #align add_comm_group.modeq.of_int_cast AddCommGroup.ModEq.of_int_cast
 #align add_comm_group.modeq.int_cast AddCommGroup.ModEq.int_cast

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 
 ! This file was ported from Lean 3 source module algebra.modeq
-! leanprover-community/mathlib commit a07d750983b94c530ab69a726862c2ab6802b38c
+! leanprover-community/mathlib commit 6cf5900728239efa287df7761ec2a1ac9cf39b29
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.GroupTheory.QuotientGroup
 /-!
 # Equality modulo an element
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file defines equality modulo an element in a commutative group.
 
 ## Main definitions

mathlib commit https://github.com/leanprover-community/mathlib/commit/2f8347015b12b0864dfaf366ec4909eb70c78740

@@ -41,301 +41,643 @@ section AddCommGroup
 
 variable [AddCommGroup α] {p a a₁ a₂ b b₁ b₂ c : α} {n : ℕ} {z : ℤ}
 
+#print AddCommGroup.ModEq /-
 /-- `a ≡ b [PMOD p]` means that `b` is congruent to `a` modulo `p`.
 
 Equivalently (as shown in `algebra.order.to_interval_mod`), `b` does not lie in the open interval
 `(a, a + p)` modulo `p`, or `to_Ico_mod hp a` disagrees with `to_Ioc_mod hp a` at `b`, or
 `to_Ico_div hp a` disagrees with `to_Ioc_div hp a` at `b`. -/
-def Modeq (p a b : α) : Prop :=
+def ModEq (p a b : α) : Prop :=
   ∃ z : ℤ, b - a = z • p
-#align add_comm_group.modeq AddCommGroup.Modeq
+#align add_comm_group.modeq AddCommGroup.ModEq
+-/
 
 -- mathport name: «expr ≡ [PMOD ]»
-notation:50 a " ≡ " b " [PMOD " p "]" => Modeq p a b
+notation:50 a " ≡ " b " [PMOD " p "]" => ModEq p a b
 
+#print AddCommGroup.modEq_refl /-
 @[refl, simp]
-theorem modeq_refl (a : α) : a ≡ a [PMOD p] :=
+theorem modEq_refl (a : α) : a ≡ a [PMOD p] :=
   ⟨0, by simp⟩
-#align add_comm_group.modeq_refl AddCommGroup.modeq_refl
+#align add_comm_group.modeq_refl AddCommGroup.modEq_refl
+-/
 
-theorem modeq_rfl : a ≡ a [PMOD p] :=
-  modeq_refl _
-#align add_comm_group.modeq_rfl AddCommGroup.modeq_rfl
+#print AddCommGroup.modEq_rfl /-
+theorem modEq_rfl : a ≡ a [PMOD p] :=
+  modEq_refl _
+#align add_comm_group.modeq_rfl AddCommGroup.modEq_rfl
+-/
 
-theorem modeq_comm : a ≡ b [PMOD p] ↔ b ≡ a [PMOD p] :=
+#print AddCommGroup.modEq_comm /-
+theorem modEq_comm : a ≡ b [PMOD p] ↔ b ≡ a [PMOD p] :=
   (Equiv.neg _).exists_congr_left.trans <| by simp [modeq, ← neg_eq_iff_eq_neg]
-#align add_comm_group.modeq_comm AddCommGroup.modeq_comm
+#align add_comm_group.modeq_comm AddCommGroup.modEq_comm
+-/
 
 alias modeq_comm ↔ modeq.symm _
-#align add_comm_group.modeq.symm AddCommGroup.Modeq.symm
+#align add_comm_group.modeq.symm AddCommGroup.ModEq.symm
 
 attribute [symm] modeq.symm
 
+#print AddCommGroup.ModEq.trans /-
 @[trans]
-theorem Modeq.trans : a ≡ b [PMOD p] → b ≡ c [PMOD p] → a ≡ c [PMOD p] := fun ⟨m, hm⟩ ⟨n, hn⟩ =>
+theorem ModEq.trans : a ≡ b [PMOD p] → b ≡ c [PMOD p] → a ≡ c [PMOD p] := fun ⟨m, hm⟩ ⟨n, hn⟩ =>
   ⟨m + n, by simp [add_smul, ← hm, ← hn]⟩
-#align add_comm_group.modeq.trans AddCommGroup.Modeq.trans
+#align add_comm_group.modeq.trans AddCommGroup.ModEq.trans
+-/
 
-instance : IsRefl _ (Modeq p) :=
-  ⟨modeq_refl⟩
+instance : IsRefl _ (ModEq p) :=
+  ⟨modEq_refl⟩
 
+/- warning: add_comm_group.neg_modeq_neg -> AddCommGroup.neg_modEq_neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) a) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) a) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.neg_modeq_neg AddCommGroup.neg_modEq_negₓ'. -/
 @[simp]
-theorem neg_modeq_neg : -a ≡ -b [PMOD p] ↔ a ≡ b [PMOD p] :=
-  modeq_comm.trans <| by simp [modeq]
-#align add_comm_group.neg_modeq_neg AddCommGroup.neg_modeq_neg
-
+theorem neg_modEq_neg : -a ≡ -b [PMOD p] ↔ a ≡ b [PMOD p] :=
+  modEq_comm.trans <| by simp [modeq]
+#align add_comm_group.neg_modeq_neg AddCommGroup.neg_modEq_neg
+
+/- warning: add_comm_group.modeq.of_neg -> AddCommGroup.ModEq.of_neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) a) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) a) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.of_neg AddCommGroup.ModEq.of_negₓ'. -/
+/- warning: add_comm_group.modeq.neg -> AddCommGroup.ModEq.neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) a) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) a) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) b))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.neg AddCommGroup.ModEq.negₓ'. -/
 alias neg_modeq_neg ↔ modeq.of_neg modeq.neg
-#align add_comm_group.modeq.of_neg AddCommGroup.Modeq.of_neg
-#align add_comm_group.modeq.neg AddCommGroup.Modeq.neg
-
+#align add_comm_group.modeq.of_neg AddCommGroup.ModEq.of_neg
+#align add_comm_group.modeq.neg AddCommGroup.ModEq.neg
+
+/- warning: add_comm_group.modeq_neg -> AddCommGroup.modEq_neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) p) a b) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) p) a b) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_neg AddCommGroup.modEq_negₓ'. -/
 @[simp]
-theorem modeq_neg : a ≡ b [PMOD -p] ↔ a ≡ b [PMOD p] :=
-  modeq_comm.trans <| by simp [modeq, ← neg_eq_iff_eq_neg]
-#align add_comm_group.modeq_neg AddCommGroup.modeq_neg
-
+theorem modEq_neg : a ≡ b [PMOD -p] ↔ a ≡ b [PMOD p] :=
+  modEq_comm.trans <| by simp [modeq, ← neg_eq_iff_eq_neg]
+#align add_comm_group.modeq_neg AddCommGroup.modEq_neg
+
+/- warning: add_comm_group.modeq.of_neg' -> AddCommGroup.ModEq.of_neg' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) p) a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) p) a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.of_neg' AddCommGroup.ModEq.of_neg'ₓ'. -/
+/- warning: add_comm_group.modeq.neg' -> AddCommGroup.ModEq.neg' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) p) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) p) a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.neg' AddCommGroup.ModEq.neg'ₓ'. -/
 alias modeq_neg ↔ modeq.of_neg' modeq.neg'
-#align add_comm_group.modeq.of_neg' AddCommGroup.Modeq.of_neg'
-#align add_comm_group.modeq.neg' AddCommGroup.Modeq.neg'
-
-theorem modeq_sub (a b : α) : a ≡ b [PMOD b - a] :=
+#align add_comm_group.modeq.of_neg' AddCommGroup.ModEq.of_neg'
+#align add_comm_group.modeq.neg' AddCommGroup.ModEq.neg'
+
+/- warning: add_comm_group.modeq_sub -> AddCommGroup.modEq_sub is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] (a : α) (b : α), AddCommGroup.ModEq.{u1} α _inst_1 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b a) a b
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] (a : α) (b : α), AddCommGroup.ModEq.{u1} α _inst_1 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b a) a b
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_sub AddCommGroup.modEq_subₓ'. -/
+theorem modEq_sub (a b : α) : a ≡ b [PMOD b - a] :=
   ⟨1, (one_smul _ _).symm⟩
-#align add_comm_group.modeq_sub AddCommGroup.modeq_sub
-
+#align add_comm_group.modeq_sub AddCommGroup.modEq_sub
+
+/- warning: add_comm_group.modeq_zero -> AddCommGroup.modEq_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))))) a b) (Eq.{succ u1} α a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))))) a b) (Eq.{succ u1} α a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_zero AddCommGroup.modEq_zeroₓ'. -/
 @[simp]
-theorem modeq_zero : a ≡ b [PMOD 0] ↔ a = b := by simp [modeq, sub_eq_zero, eq_comm]
-#align add_comm_group.modeq_zero AddCommGroup.modeq_zero
-
+theorem modEq_zero : a ≡ b [PMOD 0] ↔ a = b := by simp [modeq, sub_eq_zero, eq_comm]
+#align add_comm_group.modeq_zero AddCommGroup.modEq_zero
+
+/- warning: add_comm_group.self_modeq_zero -> AddCommGroup.self_modEq_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α}, AddCommGroup.ModEq.{u1} α _inst_1 p p (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α}, AddCommGroup.ModEq.{u1} α _inst_1 p p (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1)))))))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.self_modeq_zero AddCommGroup.self_modEq_zeroₓ'. -/
 @[simp]
-theorem self_modeq_zero : p ≡ 0 [PMOD p] :=
+theorem self_modEq_zero : p ≡ 0 [PMOD p] :=
   ⟨-1, by simp⟩
-#align add_comm_group.self_modeq_zero AddCommGroup.self_modeq_zero
-
+#align add_comm_group.self_modeq_zero AddCommGroup.self_modEq_zero
+
+/- warning: add_comm_group.zsmul_modeq_zero -> AddCommGroup.zsmul_modEq_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1)))))))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.zsmul_modeq_zero AddCommGroup.zsmul_modEq_zeroₓ'. -/
 @[simp]
-theorem zsmul_modeq_zero (z : ℤ) : z • p ≡ 0 [PMOD p] :=
+theorem zsmul_modEq_zero (z : ℤ) : z • p ≡ 0 [PMOD p] :=
   ⟨-z, by simp⟩
-#align add_comm_group.zsmul_modeq_zero AddCommGroup.zsmul_modeq_zero
-
-theorem add_zsmul_modeq (z : ℤ) : a + z • p ≡ a [PMOD p] :=
+#align add_comm_group.zsmul_modeq_zero AddCommGroup.zsmul_modEq_zero
+
+/- warning: add_comm_group.add_zsmul_modeq -> AddCommGroup.add_zsmul_modEq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p)) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p)) a
+Case conversion may be inaccurate. Consider using '#align add_comm_group.add_zsmul_modeq AddCommGroup.add_zsmul_modEqₓ'. -/
+theorem add_zsmul_modEq (z : ℤ) : a + z • p ≡ a [PMOD p] :=
   ⟨-z, by simp⟩
-#align add_comm_group.add_zsmul_modeq AddCommGroup.add_zsmul_modeq
-
-theorem zsmul_add_modeq (z : ℤ) : z • p + a ≡ a [PMOD p] :=
+#align add_comm_group.add_zsmul_modeq AddCommGroup.add_zsmul_modEq
+
+/- warning: add_comm_group.zsmul_add_modeq -> AddCommGroup.zsmul_add_modEq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p) a) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (z : Int), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p) a) a
+Case conversion may be inaccurate. Consider using '#align add_comm_group.zsmul_add_modeq AddCommGroup.zsmul_add_modEqₓ'. -/
+theorem zsmul_add_modEq (z : ℤ) : z • p + a ≡ a [PMOD p] :=
   ⟨-z, by simp⟩
-#align add_comm_group.zsmul_add_modeq AddCommGroup.zsmul_add_modeq
-
-theorem add_nsmul_modeq (n : ℕ) : a + n • p ≡ a [PMOD p] :=
+#align add_comm_group.zsmul_add_modeq AddCommGroup.zsmul_add_modEq
+
+/- warning: add_comm_group.add_nsmul_modeq -> AddCommGroup.add_nsmul_modEq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (n : Nat), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p)) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (n : Nat), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p)) a
+Case conversion may be inaccurate. Consider using '#align add_comm_group.add_nsmul_modeq AddCommGroup.add_nsmul_modEqₓ'. -/
+theorem add_nsmul_modEq (n : ℕ) : a + n • p ≡ a [PMOD p] :=
   ⟨-n, by simp⟩
-#align add_comm_group.add_nsmul_modeq AddCommGroup.add_nsmul_modeq
-
-theorem nsmul_add_modeq (n : ℕ) : n • p + a ≡ a [PMOD p] :=
+#align add_comm_group.add_nsmul_modeq AddCommGroup.add_nsmul_modEq
+
+/- warning: add_comm_group.nsmul_add_modeq -> AddCommGroup.nsmul_add_modEq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (n : Nat), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p) a) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} (n : Nat), AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p) a) a
+Case conversion may be inaccurate. Consider using '#align add_comm_group.nsmul_add_modeq AddCommGroup.nsmul_add_modEqₓ'. -/
+theorem nsmul_add_modEq (n : ℕ) : n • p + a ≡ a [PMOD p] :=
   ⟨-n, by simp⟩
-#align add_comm_group.nsmul_add_modeq AddCommGroup.nsmul_add_modeq
+#align add_comm_group.nsmul_add_modeq AddCommGroup.nsmul_add_modEq
 
 namespace Modeq
 
+/- warning: add_comm_group.modeq.add_zsmul -> AddCommGroup.ModEq.add_zsmul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (z : Int), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p)) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (z : Int), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p)) b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_zsmul AddCommGroup.ModEq.add_zsmulₓ'. -/
 protected theorem add_zsmul (z : ℤ) : a ≡ b [PMOD p] → a + z • p ≡ b [PMOD p] :=
-  (add_zsmul_modeq _).trans
-#align add_comm_group.modeq.add_zsmul AddCommGroup.Modeq.add_zsmul
-
+  (add_zsmul_modEq _).trans
+#align add_comm_group.modeq.add_zsmul AddCommGroup.ModEq.add_zsmul
+
+/- warning: add_comm_group.modeq.zsmul_add -> AddCommGroup.ModEq.zsmul_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (z : Int), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p) a) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (z : Int), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p) a) b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.zsmul_add AddCommGroup.ModEq.zsmul_addₓ'. -/
 protected theorem zsmul_add (z : ℤ) : a ≡ b [PMOD p] → z • p + a ≡ b [PMOD p] :=
-  (zsmul_add_modeq _).trans
-#align add_comm_group.modeq.zsmul_add AddCommGroup.Modeq.zsmul_add
-
+  (zsmul_add_modEq _).trans
+#align add_comm_group.modeq.zsmul_add AddCommGroup.ModEq.zsmul_add
+
+/- warning: add_comm_group.modeq.add_nsmul -> AddCommGroup.ModEq.add_nsmul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (n : Nat), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p)) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (n : Nat), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p)) b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_nsmul AddCommGroup.ModEq.add_nsmulₓ'. -/
 protected theorem add_nsmul (n : ℕ) : a ≡ b [PMOD p] → a + n • p ≡ b [PMOD p] :=
-  (add_nsmul_modeq _).trans
-#align add_comm_group.modeq.add_nsmul AddCommGroup.Modeq.add_nsmul
-
+  (add_nsmul_modEq _).trans
+#align add_comm_group.modeq.add_nsmul AddCommGroup.ModEq.add_nsmul
+
+/- warning: add_comm_group.modeq.nsmul_add -> AddCommGroup.ModEq.nsmul_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (n : Nat), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p) a) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (n : Nat), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p) a) b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.nsmul_add AddCommGroup.ModEq.nsmul_addₓ'. -/
 protected theorem nsmul_add (n : ℕ) : a ≡ b [PMOD p] → n • p + a ≡ b [PMOD p] :=
-  (nsmul_add_modeq _).trans
-#align add_comm_group.modeq.nsmul_add AddCommGroup.Modeq.nsmul_add
+  (nsmul_add_modEq _).trans
+#align add_comm_group.modeq.nsmul_add AddCommGroup.ModEq.nsmul_add
 
+#print AddCommGroup.ModEq.of_zsmul /-
 protected theorem of_zsmul : a ≡ b [PMOD z • p] → a ≡ b [PMOD p] := fun ⟨m, hm⟩ =>
   ⟨m * z, by rwa [mul_smul]⟩
-#align add_comm_group.modeq.of_zsmul AddCommGroup.Modeq.of_zsmul
+#align add_comm_group.modeq.of_zsmul AddCommGroup.ModEq.of_zsmul
+-/
 
+#print AddCommGroup.ModEq.of_nsmul /-
 protected theorem of_nsmul : a ≡ b [PMOD n • p] → a ≡ b [PMOD p] := fun ⟨m, hm⟩ =>
   ⟨m * n, by rwa [mul_smul, coe_nat_zsmul]⟩
-#align add_comm_group.modeq.of_nsmul AddCommGroup.Modeq.of_nsmul
+#align add_comm_group.modeq.of_nsmul AddCommGroup.ModEq.of_nsmul
+-/
 
+#print AddCommGroup.ModEq.zsmul /-
 protected theorem zsmul : a ≡ b [PMOD p] → z • a ≡ z • b [PMOD z • p] :=
   Exists.imp fun m hm => by rw [← smul_sub, hm, smul_comm]
-#align add_comm_group.modeq.zsmul AddCommGroup.Modeq.zsmul
+#align add_comm_group.modeq.zsmul AddCommGroup.ModEq.zsmul
+-/
 
+#print AddCommGroup.ModEq.nsmul /-
 protected theorem nsmul : a ≡ b [PMOD p] → n • a ≡ n • b [PMOD n • p] :=
   Exists.imp fun m hm => by rw [← smul_sub, hm, smul_comm]
-#align add_comm_group.modeq.nsmul AddCommGroup.Modeq.nsmul
+#align add_comm_group.modeq.nsmul AddCommGroup.ModEq.nsmul
+-/
 
 end Modeq
 
+/- warning: add_comm_group.zsmul_modeq_zsmul -> AddCommGroup.zsmul_modEq_zsmul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {z : Int} [_inst_2 : NoZeroSMulDivisors.{0, u1} Int α Int.hasZero (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))], (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z a) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {z : Int} [_inst_2 : NoZeroSMulDivisors.{0, u1} Int α (CommMonoidWithZero.toZero.{0} Int (CancelCommMonoidWithZero.toCommMonoidWithZero.{0} Int (IsDomain.toCancelCommMonoidWithZero.{0} Int Int.instCommSemiringInt (LinearOrderedRing.isDomain.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))], (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z a) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.zsmul_modeq_zsmul AddCommGroup.zsmul_modEq_zsmulₓ'. -/
 @[simp]
-theorem zsmul_modeq_zsmul [NoZeroSMulDivisors ℤ α] (hn : z ≠ 0) :
+theorem zsmul_modEq_zsmul [NoZeroSMulDivisors ℤ α] (hn : z ≠ 0) :
     z • a ≡ z • b [PMOD z • p] ↔ a ≡ b [PMOD p] :=
   exists_congr fun m => by rw [← smul_sub, smul_comm, smul_right_inj hn] <;> infer_instance
-#align add_comm_group.zsmul_modeq_zsmul AddCommGroup.zsmul_modeq_zsmul
-
+#align add_comm_group.zsmul_modeq_zsmul AddCommGroup.zsmul_modEq_zsmul
+
+/- warning: add_comm_group.nsmul_modeq_nsmul -> AddCommGroup.nsmul_modEq_nsmul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {n : Nat} [_inst_2 : NoZeroSMulDivisors.{0, u1} Nat α Nat.hasZero (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))], (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n a) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {n : Nat} [_inst_2 : NoZeroSMulDivisors.{0, u1} Nat α (LinearOrderedCommMonoidWithZero.toZero.{0} Nat Nat.linearOrderedCommMonoidWithZero) (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))], (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n a) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n b)) (AddCommGroup.ModEq.{u1} α _inst_1 p a b))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.nsmul_modeq_nsmul AddCommGroup.nsmul_modEq_nsmulₓ'. -/
 @[simp]
-theorem nsmul_modeq_nsmul [NoZeroSMulDivisors ℕ α] (hn : n ≠ 0) :
+theorem nsmul_modEq_nsmul [NoZeroSMulDivisors ℕ α] (hn : n ≠ 0) :
     n • a ≡ n • b [PMOD n • p] ↔ a ≡ b [PMOD p] :=
   exists_congr fun m => by rw [← smul_sub, smul_comm, smul_right_inj hn] <;> infer_instance
-#align add_comm_group.nsmul_modeq_nsmul AddCommGroup.nsmul_modeq_nsmul
-
+#align add_comm_group.nsmul_modeq_nsmul AddCommGroup.nsmul_modEq_nsmul
+
+/- warning: add_comm_group.modeq.zsmul_cancel -> AddCommGroup.ModEq.zsmul_cancel is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {z : Int} [_inst_2 : NoZeroSMulDivisors.{0, u1} Int α Int.hasZero (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))], (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))) -> (AddCommGroup.ModEq.{u1} α _inst_1 (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z a) (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {z : Int} [_inst_2 : NoZeroSMulDivisors.{0, u1} Int α (CommMonoidWithZero.toZero.{0} Int (CancelCommMonoidWithZero.toCommMonoidWithZero.{0} Int (IsDomain.toCancelCommMonoidWithZero.{0} Int Int.instCommSemiringInt (LinearOrderedRing.isDomain.{0} Int (LinearOrderedCommRing.toLinearOrderedRing.{0} Int Int.linearOrderedCommRing))))) (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))], (Ne.{1} Int z (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))) -> (AddCommGroup.ModEq.{u1} α _inst_1 (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z a) (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.zsmul_cancel AddCommGroup.ModEq.zsmul_cancelₓ'. -/
 alias zsmul_modeq_zsmul ↔ modeq.zsmul_cancel _
-#align add_comm_group.modeq.zsmul_cancel AddCommGroup.Modeq.zsmul_cancel
-
+#align add_comm_group.modeq.zsmul_cancel AddCommGroup.ModEq.zsmul_cancel
+
+/- warning: add_comm_group.modeq.nsmul_cancel -> AddCommGroup.ModEq.nsmul_cancel is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {n : Nat} [_inst_2 : NoZeroSMulDivisors.{0, u1} Nat α Nat.hasZero (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))], (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) -> (AddCommGroup.ModEq.{u1} α _inst_1 (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n p) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n a) (SMul.smul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) n b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {n : Nat} [_inst_2 : NoZeroSMulDivisors.{0, u1} Nat α (LinearOrderedCommMonoidWithZero.toZero.{0} Nat Nat.linearOrderedCommMonoidWithZero) (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))) (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))], (Ne.{1} Nat n (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) -> (AddCommGroup.ModEq.{u1} α _inst_1 (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n p) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n a) (HSMul.hSMul.{0, u1, u1} Nat α α (instHSMul.{0, u1} Nat α (AddMonoid.SMul.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))) n b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.nsmul_cancel AddCommGroup.ModEq.nsmul_cancelₓ'. -/
 alias nsmul_modeq_nsmul ↔ modeq.nsmul_cancel _
-#align add_comm_group.modeq.nsmul_cancel AddCommGroup.Modeq.nsmul_cancel
+#align add_comm_group.modeq.nsmul_cancel AddCommGroup.ModEq.nsmul_cancel
 
 namespace Modeq
 
+/- warning: add_comm_group.modeq.add_iff_left -> AddCommGroup.ModEq.add_iff_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_iff_left AddCommGroup.ModEq.add_iff_leftₓ'. -/
 @[simp]
 protected theorem add_iff_left :
     a₁ ≡ b₁ [PMOD p] → (a₁ + a₂ ≡ b₁ + b₂ [PMOD p] ↔ a₂ ≡ b₂ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.addLeft m).symm.exists_congr_left.trans <| by simpa [add_sub_add_comm, hm, add_smul]
-#align add_comm_group.modeq.add_iff_left AddCommGroup.Modeq.add_iff_left
-
+#align add_comm_group.modeq.add_iff_left AddCommGroup.ModEq.add_iff_left
+
+/- warning: add_comm_group.modeq.add_iff_right -> AddCommGroup.ModEq.add_iff_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_iff_right AddCommGroup.ModEq.add_iff_rightₓ'. -/
 @[simp]
 protected theorem add_iff_right :
     a₂ ≡ b₂ [PMOD p] → (a₁ + a₂ ≡ b₁ + b₂ [PMOD p] ↔ a₁ ≡ b₁ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.addRight m).symm.exists_congr_left.trans <| by simpa [add_sub_add_comm, hm, add_smul]
-#align add_comm_group.modeq.add_iff_right AddCommGroup.Modeq.add_iff_right
-
+#align add_comm_group.modeq.add_iff_right AddCommGroup.ModEq.add_iff_right
+
+/- warning: add_comm_group.modeq.sub_iff_left -> AddCommGroup.ModEq.sub_iff_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_iff_left AddCommGroup.ModEq.sub_iff_leftₓ'. -/
 @[simp]
 protected theorem sub_iff_left :
     a₁ ≡ b₁ [PMOD p] → (a₁ - a₂ ≡ b₁ - b₂ [PMOD p] ↔ a₂ ≡ b₂ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.subLeft m).symm.exists_congr_left.trans <| by simpa [sub_sub_sub_comm, hm, sub_smul]
-#align add_comm_group.modeq.sub_iff_left AddCommGroup.Modeq.sub_iff_left
-
+#align add_comm_group.modeq.sub_iff_left AddCommGroup.ModEq.sub_iff_left
+
+/- warning: add_comm_group.modeq.sub_iff_right -> AddCommGroup.ModEq.sub_iff_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_iff_right AddCommGroup.ModEq.sub_iff_rightₓ'. -/
 @[simp]
 protected theorem sub_iff_right :
     a₂ ≡ b₂ [PMOD p] → (a₁ - a₂ ≡ b₁ - b₂ [PMOD p] ↔ a₁ ≡ b₁ [PMOD p]) := fun ⟨m, hm⟩ =>
   (Equiv.subRight m).symm.exists_congr_left.trans <| by simpa [sub_sub_sub_comm, hm, sub_smul]
-#align add_comm_group.modeq.sub_iff_right AddCommGroup.Modeq.sub_iff_right
-
+#align add_comm_group.modeq.sub_iff_right AddCommGroup.ModEq.sub_iff_right
+
+/- warning: add_comm_group.modeq.add_left_cancel -> AddCommGroup.ModEq.add_left_cancel is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_left_cancel AddCommGroup.ModEq.add_left_cancelₓ'. -/
+/- warning: add_comm_group.modeq.add -> AddCommGroup.ModEq.add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add AddCommGroup.ModEq.addₓ'. -/
 alias modeq.add_iff_left ↔ add_left_cancel add
-#align add_comm_group.modeq.add_left_cancel AddCommGroup.Modeq.add_left_cancel
-#align add_comm_group.modeq.add AddCommGroup.Modeq.add
-
+#align add_comm_group.modeq.add_left_cancel AddCommGroup.ModEq.add_left_cancel
+#align add_comm_group.modeq.add AddCommGroup.ModEq.add
+
+/- warning: add_comm_group.modeq.add_right_cancel -> AddCommGroup.ModEq.add_right_cancel is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a₁ a₂) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_right_cancel AddCommGroup.ModEq.add_right_cancelₓ'. -/
 alias modeq.add_iff_right ↔ add_right_cancel _
-#align add_comm_group.modeq.add_right_cancel AddCommGroup.Modeq.add_right_cancel
-
+#align add_comm_group.modeq.add_right_cancel AddCommGroup.ModEq.add_right_cancel
+
+/- warning: add_comm_group.modeq.sub_left_cancel -> AddCommGroup.ModEq.sub_left_cancel is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_left_cancel AddCommGroup.ModEq.sub_left_cancelₓ'. -/
+/- warning: add_comm_group.modeq.sub -> AddCommGroup.ModEq.sub is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub AddCommGroup.ModEq.subₓ'. -/
 alias modeq.sub_iff_left ↔ sub_left_cancel sub
-#align add_comm_group.modeq.sub_left_cancel AddCommGroup.Modeq.sub_left_cancel
-#align add_comm_group.modeq.sub AddCommGroup.Modeq.sub
-
+#align add_comm_group.modeq.sub_left_cancel AddCommGroup.ModEq.sub_left_cancel
+#align add_comm_group.modeq.sub AddCommGroup.ModEq.sub
+
+/- warning: add_comm_group.modeq.sub_right_cancel -> AddCommGroup.ModEq.sub_right_cancel is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (AddCommGroup.ModEq.{u1} α _inst_1 p a₂ b₂) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a₁ a₂) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b₁ b₂)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a₁ b₁)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_right_cancel AddCommGroup.ModEq.sub_right_cancelₓ'. -/
 alias modeq.sub_iff_right ↔ sub_right_cancel _
-#align add_comm_group.modeq.sub_right_cancel AddCommGroup.Modeq.sub_right_cancel
+#align add_comm_group.modeq.sub_right_cancel AddCommGroup.ModEq.sub_right_cancel
 
 attribute [protected] add_left_cancel add_right_cancel add sub_left_cancel sub_right_cancel sub
 
+/- warning: add_comm_group.modeq.add_left -> AddCommGroup.ModEq.add_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_left AddCommGroup.ModEq.add_leftₓ'. -/
 protected theorem add_left (c : α) (h : a ≡ b [PMOD p]) : c + a ≡ c + b [PMOD p] :=
-  modeq_rfl.add h
-#align add_comm_group.modeq.add_left AddCommGroup.Modeq.add_left
-
+  modEq_rfl.add h
+#align add_comm_group.modeq.add_left AddCommGroup.ModEq.add_left
+
+/- warning: add_comm_group.modeq.sub_left -> AddCommGroup.ModEq.sub_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c b))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_left AddCommGroup.ModEq.sub_leftₓ'. -/
 protected theorem sub_left (c : α) (h : a ≡ b [PMOD p]) : c - a ≡ c - b [PMOD p] :=
-  modeq_rfl.sub h
-#align add_comm_group.modeq.sub_left AddCommGroup.Modeq.sub_left
-
+  modEq_rfl.sub h
+#align add_comm_group.modeq.sub_left AddCommGroup.ModEq.sub_left
+
+/- warning: add_comm_group.modeq.add_right -> AddCommGroup.ModEq.add_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_right AddCommGroup.ModEq.add_rightₓ'. -/
 protected theorem add_right (c : α) (h : a ≡ b [PMOD p]) : a + c ≡ b + c [PMOD p] :=
-  h.add modeq_rfl
-#align add_comm_group.modeq.add_right AddCommGroup.Modeq.add_right
-
+  h.add modEq_rfl
+#align add_comm_group.modeq.add_right AddCommGroup.ModEq.add_right
+
+/- warning: add_comm_group.modeq.sub_right -> AddCommGroup.ModEq.sub_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p a b) -> (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_right AddCommGroup.ModEq.sub_rightₓ'. -/
 protected theorem sub_right (c : α) (h : a ≡ b [PMOD p]) : a - c ≡ b - c [PMOD p] :=
-  h.sub modeq_rfl
-#align add_comm_group.modeq.sub_right AddCommGroup.Modeq.sub_right
-
+  h.sub modEq_rfl
+#align add_comm_group.modeq.sub_right AddCommGroup.ModEq.sub_right
+
+/- warning: add_comm_group.modeq.add_left_cancel' -> AddCommGroup.ModEq.add_left_cancel' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_left_cancel' AddCommGroup.ModEq.add_left_cancel'ₓ'. -/
 protected theorem add_left_cancel' (c : α) : c + a ≡ c + b [PMOD p] → a ≡ b [PMOD p] :=
-  modeq_rfl.add_left_cancel
-#align add_comm_group.modeq.add_left_cancel' AddCommGroup.Modeq.add_left_cancel'
-
+  modEq_rfl.add_left_cancel
+#align add_comm_group.modeq.add_left_cancel' AddCommGroup.ModEq.add_left_cancel'
+
+/- warning: add_comm_group.modeq.add_right_cancel' -> AddCommGroup.ModEq.add_right_cancel' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.add_right_cancel' AddCommGroup.ModEq.add_right_cancel'ₓ'. -/
 protected theorem add_right_cancel' (c : α) : a + c ≡ b + c [PMOD p] → a ≡ b [PMOD p] :=
-  modeq_rfl.add_right_cancel
-#align add_comm_group.modeq.add_right_cancel' AddCommGroup.Modeq.add_right_cancel'
-
+  modEq_rfl.add_right_cancel
+#align add_comm_group.modeq.add_right_cancel' AddCommGroup.ModEq.add_right_cancel'
+
+/- warning: add_comm_group.modeq.sub_left_cancel' -> AddCommGroup.ModEq.sub_left_cancel' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c b)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_left_cancel' AddCommGroup.ModEq.sub_left_cancel'ₓ'. -/
 protected theorem sub_left_cancel' (c : α) : c - a ≡ c - b [PMOD p] → a ≡ b [PMOD p] :=
-  modeq_rfl.sub_left_cancel
-#align add_comm_group.modeq.sub_left_cancel' AddCommGroup.Modeq.sub_left_cancel'
-
+  modEq_rfl.sub_left_cancel
+#align add_comm_group.modeq.sub_left_cancel' AddCommGroup.ModEq.sub_left_cancel'
+
+/- warning: add_comm_group.modeq.sub_right_cancel' -> AddCommGroup.ModEq.sub_right_cancel' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} (c : α), (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) -> (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.sub_right_cancel' AddCommGroup.ModEq.sub_right_cancel'ₓ'. -/
 protected theorem sub_right_cancel' (c : α) : a - c ≡ b - c [PMOD p] → a ≡ b [PMOD p] :=
-  modeq_rfl.sub_right_cancel
-#align add_comm_group.modeq.sub_right_cancel' AddCommGroup.Modeq.sub_right_cancel'
+  modEq_rfl.sub_right_cancel
+#align add_comm_group.modeq.sub_right_cancel' AddCommGroup.ModEq.sub_right_cancel'
 
 end Modeq
 
-theorem modeq_sub_iff_add_modeq' : a ≡ b - c [PMOD p] ↔ c + a ≡ b [PMOD p] := by
+/- warning: add_comm_group.modeq_sub_iff_add_modeq' -> AddCommGroup.modEq_sub_iff_add_modEq' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c a) b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_sub_iff_add_modeq' AddCommGroup.modEq_sub_iff_add_modEq'ₓ'. -/
+theorem modEq_sub_iff_add_modEq' : a ≡ b - c [PMOD p] ↔ c + a ≡ b [PMOD p] := by
   simp [modeq, sub_sub]
-#align add_comm_group.modeq_sub_iff_add_modeq' AddCommGroup.modeq_sub_iff_add_modeq'
-
-theorem modeq_sub_iff_add_modeq : a ≡ b - c [PMOD p] ↔ a + c ≡ b [PMOD p] :=
-  modeq_sub_iff_add_modeq'.trans <| by rw [add_comm]
-#align add_comm_group.modeq_sub_iff_add_modeq AddCommGroup.modeq_sub_iff_add_modeq
-
-theorem sub_modeq_iff_modeq_add' : a - b ≡ c [PMOD p] ↔ a ≡ b + c [PMOD p] :=
-  modeq_comm.trans <| modeq_sub_iff_add_modeq'.trans modeq_comm
-#align add_comm_group.sub_modeq_iff_modeq_add' AddCommGroup.sub_modeq_iff_modeq_add'
-
-theorem sub_modeq_iff_modeq_add : a - b ≡ c [PMOD p] ↔ a ≡ c + b [PMOD p] :=
-  modeq_comm.trans <| modeq_sub_iff_add_modeq.trans modeq_comm
-#align add_comm_group.sub_modeq_iff_modeq_add AddCommGroup.sub_modeq_iff_modeq_add
-
+#align add_comm_group.modeq_sub_iff_add_modeq' AddCommGroup.modEq_sub_iff_add_modEq'
+
+/- warning: add_comm_group.modeq_sub_iff_add_modeq -> AddCommGroup.modEq_sub_iff_add_modEq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) b c)) (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a c) b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_sub_iff_add_modeq AddCommGroup.modEq_sub_iff_add_modEqₓ'. -/
+theorem modEq_sub_iff_add_modEq : a ≡ b - c [PMOD p] ↔ a + c ≡ b [PMOD p] :=
+  modEq_sub_iff_add_modEq'.trans <| by rw [add_comm]
+#align add_comm_group.modeq_sub_iff_add_modeq AddCommGroup.modEq_sub_iff_add_modEq
+
+/- warning: add_comm_group.sub_modeq_iff_modeq_add' -> AddCommGroup.sub_modEq_iff_modEq_add' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) (AddCommGroup.ModEq.{u1} α _inst_1 p a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) (AddCommGroup.ModEq.{u1} α _inst_1 p a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.sub_modeq_iff_modeq_add' AddCommGroup.sub_modEq_iff_modEq_add'ₓ'. -/
+theorem sub_modEq_iff_modEq_add' : a - b ≡ c [PMOD p] ↔ a ≡ b + c [PMOD p] :=
+  modEq_comm.trans <| modEq_sub_iff_add_modEq'.trans modEq_comm
+#align add_comm_group.sub_modeq_iff_modeq_add' AddCommGroup.sub_modEq_iff_modEq_add'
+
+/- warning: add_comm_group.sub_modeq_iff_modeq_add -> AddCommGroup.sub_modEq_iff_modEq_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) (AddCommGroup.ModEq.{u1} α _inst_1 p a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α} {c : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) (AddCommGroup.ModEq.{u1} α _inst_1 p a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) c b))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.sub_modeq_iff_modeq_add AddCommGroup.sub_modEq_iff_modEq_addₓ'. -/
+theorem sub_modEq_iff_modEq_add : a - b ≡ c [PMOD p] ↔ a ≡ c + b [PMOD p] :=
+  modEq_comm.trans <| modEq_sub_iff_add_modEq.trans modEq_comm
+#align add_comm_group.sub_modeq_iff_modeq_add AddCommGroup.sub_modEq_iff_modEq_add
+
+/- warning: add_comm_group.sub_modeq_zero -> AddCommGroup.sub_modEq_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))))) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1)))))))) (AddCommGroup.ModEq.{u1} α _inst_1 p a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.sub_modeq_zero AddCommGroup.sub_modEq_zeroₓ'. -/
 @[simp]
-theorem sub_modeq_zero : a - b ≡ 0 [PMOD p] ↔ a ≡ b [PMOD p] := by simp [sub_modeq_iff_modeq_add]
-#align add_comm_group.sub_modeq_zero AddCommGroup.sub_modeq_zero
-
+theorem sub_modEq_zero : a - b ≡ 0 [PMOD p] ↔ a ≡ b [PMOD p] := by simp [sub_modeq_iff_modeq_add]
+#align add_comm_group.sub_modeq_zero AddCommGroup.sub_modEq_zero
+
+/- warning: add_comm_group.add_modeq_left -> AddCommGroup.add_modEq_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) a) (AddCommGroup.ModEq.{u1} α _inst_1 p b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) a) (AddCommGroup.ModEq.{u1} α _inst_1 p b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.add_modeq_left AddCommGroup.add_modEq_leftₓ'. -/
 @[simp]
-theorem add_modeq_left : a + b ≡ a [PMOD p] ↔ b ≡ 0 [PMOD p] := by simp [← modeq_sub_iff_add_modeq']
-#align add_comm_group.add_modeq_left AddCommGroup.add_modeq_left
-
+theorem add_modEq_left : a + b ≡ a [PMOD p] ↔ b ≡ 0 [PMOD p] := by simp [← modeq_sub_iff_add_modeq']
+#align add_comm_group.add_modeq_left AddCommGroup.add_modEq_left
+
+/- warning: add_comm_group.add_modeq_right -> AddCommGroup.add_modEq_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) b) (AddCommGroup.ModEq.{u1} α _inst_1 p a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) b) (AddCommGroup.ModEq.{u1} α _inst_1 p a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α _inst_1))))))))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.add_modeq_right AddCommGroup.add_modEq_rightₓ'. -/
 @[simp]
-theorem add_modeq_right : a + b ≡ b [PMOD p] ↔ a ≡ 0 [PMOD p] := by simp [← modeq_sub_iff_add_modeq]
-#align add_comm_group.add_modeq_right AddCommGroup.add_modeq_right
-
-theorem modeq_iff_eq_add_zsmul : a ≡ b [PMOD p] ↔ ∃ z : ℤ, b = a + z • p := by
+theorem add_modEq_right : a + b ≡ b [PMOD p] ↔ a ≡ 0 [PMOD p] := by simp [← modeq_sub_iff_add_modeq]
+#align add_comm_group.add_modeq_right AddCommGroup.add_modEq_right
+
+/- warning: add_comm_group.modeq_iff_eq_add_zsmul -> AddCommGroup.modEq_iff_eq_add_zsmul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a b) (Exists.{1} Int (fun (z : Int) => Eq.{succ u1} α b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (AddCommGroup.ModEq.{u1} α _inst_1 p a b) (Exists.{1} Int (fun (z : Int) => Eq.{succ u1} α b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p))))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_iff_eq_add_zsmul AddCommGroup.modEq_iff_eq_add_zsmulₓ'. -/
+theorem modEq_iff_eq_add_zsmul : a ≡ b [PMOD p] ↔ ∃ z : ℤ, b = a + z • p := by
   simp_rw [modeq, sub_eq_iff_eq_add']
-#align add_comm_group.modeq_iff_eq_add_zsmul AddCommGroup.modeq_iff_eq_add_zsmul
-
-theorem not_modeq_iff_ne_add_zsmul : ¬a ≡ b [PMOD p] ↔ ∀ z : ℤ, b ≠ a + z • p := by
+#align add_comm_group.modeq_iff_eq_add_zsmul AddCommGroup.modEq_iff_eq_add_zsmul
+
+/- warning: add_comm_group.not_modeq_iff_ne_add_zsmul -> AddCommGroup.not_modEq_iff_ne_add_zsmul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (Not (AddCommGroup.ModEq.{u1} α _inst_1 p a b)) (forall (z : Int), Ne.{succ u1} α b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (SMul.smul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))) z p)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] {p : α} {a : α} {b : α}, Iff (Not (AddCommGroup.ModEq.{u1} α _inst_1 p a b)) (forall (z : Int), Ne.{succ u1} α b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a (HSMul.hSMul.{0, u1, u1} Int α α (instHSMul.{0, u1} Int α (SubNegMonoid.SMulInt.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) z p)))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.not_modeq_iff_ne_add_zsmul AddCommGroup.not_modEq_iff_ne_add_zsmulₓ'. -/
+theorem not_modEq_iff_ne_add_zsmul : ¬a ≡ b [PMOD p] ↔ ∀ z : ℤ, b ≠ a + z • p := by
   rw [modeq_iff_eq_add_zsmul, not_exists]
-#align add_comm_group.not_modeq_iff_ne_add_zsmul AddCommGroup.not_modeq_iff_ne_add_zsmul
+#align add_comm_group.not_modeq_iff_ne_add_zsmul AddCommGroup.not_modEq_iff_ne_add_zsmul
 
-theorem modeq_iff_eq_mod_zmultiples : a ≡ b [PMOD p] ↔ (b : α ⧸ AddSubgroup.zmultiples p) = a := by
+#print AddCommGroup.modEq_iff_eq_mod_zmultiples /-
+theorem modEq_iff_eq_mod_zmultiples : a ≡ b [PMOD p] ↔ (b : α ⧸ AddSubgroup.zmultiples p) = a := by
   simp_rw [modeq_iff_eq_add_zsmul, QuotientAddGroup.eq_iff_sub_mem, AddSubgroup.mem_zmultiples_iff,
     eq_sub_iff_add_eq', eq_comm]
-#align add_comm_group.modeq_iff_eq_mod_zmultiples AddCommGroup.modeq_iff_eq_mod_zmultiples
+#align add_comm_group.modeq_iff_eq_mod_zmultiples AddCommGroup.modEq_iff_eq_mod_zmultiples
+-/
 
-theorem not_modeq_iff_ne_mod_zmultiples :
+#print AddCommGroup.not_modEq_iff_ne_mod_zmultiples /-
+theorem not_modEq_iff_ne_mod_zmultiples :
     ¬a ≡ b [PMOD p] ↔ (b : α ⧸ AddSubgroup.zmultiples p) ≠ a :=
-  modeq_iff_eq_mod_zmultiples.Not
-#align add_comm_group.not_modeq_iff_ne_mod_zmultiples AddCommGroup.not_modeq_iff_ne_mod_zmultiples
+  modEq_iff_eq_mod_zmultiples.Not
+#align add_comm_group.not_modeq_iff_ne_mod_zmultiples AddCommGroup.not_modEq_iff_ne_mod_zmultiples
+-/
 
 end AddCommGroup
 
+/- warning: add_comm_group.modeq_iff_int_modeq -> AddCommGroup.modEq_iff_int_modEq is a dubious translation:
+lean 3 declaration is
+  forall {a : Int} {b : Int} {z : Int}, Iff (AddCommGroup.ModEq.{0} Int Int.addCommGroup z a b) (Int.ModEq z a b)
+but is expected to have type
+  forall {a : Int} {b : Int} {z : Int}, Iff (AddCommGroup.ModEq.{0} Int Int.instAddCommGroupInt z a b) (Int.ModEq z a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq_iff_int_modeq AddCommGroup.modEq_iff_int_modEqₓ'. -/
 @[simp]
-theorem modeq_iff_int_modeq {a b z : ℤ} : a ≡ b [PMOD z] ↔ a ≡ b [ZMOD z] := by
+theorem modEq_iff_int_modEq {a b z : ℤ} : a ≡ b [PMOD z] ↔ a ≡ b [ZMOD z] := by
   simp [modeq, dvd_iff_exists_eq_mul_left, Int.modEq_iff_dvd]
-#align add_comm_group.modeq_iff_int_modeq AddCommGroup.modeq_iff_int_modeq
+#align add_comm_group.modeq_iff_int_modeq AddCommGroup.modEq_iff_int_modEq
 
 section AddCommGroupWithOne
 
 variable [AddCommGroupWithOne α] [CharZero α]
 
+/- warning: add_comm_group.int_cast_modeq_int_cast -> AddCommGroup.int_cast_modEq_int_cast is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, Iff (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) z) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) a) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) b)) (AddCommGroup.ModEq.{0} Int Int.addCommGroup z a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, Iff (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) z) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) a) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) b)) (AddCommGroup.ModEq.{0} Int Int.instAddCommGroupInt z a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.int_cast_modeq_int_cast AddCommGroup.int_cast_modEq_int_castₓ'. -/
 @[simp, norm_cast]
-theorem int_cast_modeq_int_cast {a b z : ℤ} : a ≡ b [PMOD (z : α)] ↔ a ≡ b [PMOD z] := by
+theorem int_cast_modEq_int_cast {a b z : ℤ} : a ≡ b [PMOD (z : α)] ↔ a ≡ b [PMOD z] := by
   simp_rw [modeq, ← Int.cast_mul_eq_zsmul_cast] <;> norm_cast
-#align add_comm_group.int_cast_modeq_int_cast AddCommGroup.int_cast_modeq_int_cast
+#align add_comm_group.int_cast_modeq_int_cast AddCommGroup.int_cast_modEq_int_cast
 
+#print AddCommGroup.nat_cast_modEq_nat_cast /-
 @[simp, norm_cast]
-theorem nat_cast_modeq_nat_cast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [MOD n] := by
+theorem nat_cast_modEq_nat_cast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [MOD n] := by
   simp_rw [← Int.coe_nat_modEq_iff, ← modeq_iff_int_modeq, ← @int_cast_modeq_int_cast α,
     Int.cast_ofNat]
-#align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.nat_cast_modeq_nat_cast
+#align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.nat_cast_modEq_nat_cast
+-/
 
+/- warning: add_comm_group.modeq.of_int_cast -> AddCommGroup.ModEq.of_int_cast is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) z) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) a) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) b)) -> (AddCommGroup.ModEq.{0} Int Int.addCommGroup z a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) z) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) a) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) b)) -> (AddCommGroup.ModEq.{0} Int Int.instAddCommGroupInt z a b)
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.of_int_cast AddCommGroup.ModEq.of_int_castₓ'. -/
+/- warning: add_comm_group.modeq.int_cast -> AddCommGroup.ModEq.int_cast is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, (AddCommGroup.ModEq.{0} Int Int.addCommGroup z a b) -> (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) z) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) a) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int α (HasLiftT.mk.{1, succ u1} Int α (CoeTCₓ.coe.{1, succ u1} Int α (Int.castCoe.{u1} α (AddGroupWithOne.toHasIntCast.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))))) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : AddCommGroupWithOne.{u1} α] [_inst_2 : CharZero.{u1} α (AddGroupWithOne.toAddMonoidWithOne.{u1} α (AddCommGroupWithOne.toAddGroupWithOne.{u1} α _inst_1))] {a : Int} {b : Int} {z : Int}, (AddCommGroup.ModEq.{0} Int Int.instAddCommGroupInt z a b) -> (AddCommGroup.ModEq.{u1} α (AddCommGroupWithOne.toAddCommGroup.{u1} α _inst_1) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) z) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) a) (Int.cast.{u1} α (AddCommGroupWithOne.toIntCast.{u1} α _inst_1) b))
+Case conversion may be inaccurate. Consider using '#align add_comm_group.modeq.int_cast AddCommGroup.ModEq.int_castₓ'. -/
 alias int_cast_modeq_int_cast ↔ modeq.of_int_cast modeq.int_cast
-#align add_comm_group.modeq.of_int_cast AddCommGroup.Modeq.of_int_cast
-#align add_comm_group.modeq.int_cast AddCommGroup.Modeq.int_cast
+#align add_comm_group.modeq.of_int_cast AddCommGroup.ModEq.of_int_cast
+#align add_comm_group.modeq.int_cast AddCommGroup.ModEq.int_cast
 
 alias nat_cast_modeq_nat_cast ↔ _root_.nat.modeq.of_nat_cast modeq.nat_cast
 #align nat.modeq.of_nat_cast Nat.ModEq.of_nat_cast
-#align add_comm_group.modeq.nat_cast AddCommGroup.Modeq.nat_cast
+#align add_comm_group.modeq.nat_cast AddCommGroup.ModEq.nat_cast
 
 end AddCommGroupWithOne
 

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

This renames

• Int.cast_ofNat to Int.cast_natCast
• Int.int_cast_ofNat to Int.cast_ofNat

I think the history here is that this lemma was previously about Int.ofNat, before we globally fixed the simp-normal form to be Nat.cast.

Since the Int.cast_ofNat name is repurposed, it can't be deprecated. Int.int_cast_ofNat is such a wonky name that it was probably never used.

@@ -329,7 +329,7 @@ lemma intCast_modEq_intCast' {a b : ℤ} {n : ℕ} : a ≡ b [PMOD (n : α)] ↔
 @[simp, norm_cast]
 theorem natCast_modEq_natCast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [MOD n] := by
   simp_rw [← Int.natCast_modEq_iff, ← modEq_iff_int_modEq, ← @intCast_modEq_intCast α,
-    Int.cast_ofNat]
+    Int.cast_natCast]
 #align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.natCast_modEq_natCast
 
 alias ⟨ModEq.of_intCast, ModEq.intCast⟩ := intCast_modEq_intCast

Reduce the diff of #11499

Renames

All in the Int namespace:

• ofNat_eq_cast → ofNat_eq_natCast
• cast_eq_cast_iff_Nat → natCast_inj
• natCast_eq_ofNat → ofNat_eq_natCast
• coe_nat_sub → natCast_sub
• coe_nat_nonneg → natCast_nonneg
• sign_coe_add_one → sign_natCast_add_one
• nat_succ_eq_int_succ → natCast_succ
• succ_neg_nat_succ → succ_neg_natCast_succ
• coe_pred_of_pos → natCast_pred_of_pos
• coe_nat_div → natCast_div
• coe_nat_ediv → natCast_ediv
• sign_coe_nat_of_nonzero → sign_natCast_of_ne_zero
• toNat_coe_nat → toNat_natCast
• toNat_coe_nat_add_one → toNat_natCast_add_one
• coe_nat_dvd → natCast_dvd_natCast
• coe_nat_dvd_left → natCast_dvd
• coe_nat_dvd_right → dvd_natCast
• le_coe_nat_sub → le_natCast_sub
• succ_coe_nat_pos → succ_natCast_pos
• coe_nat_modEq_iff → natCast_modEq_iff
• coe_natAbs → natCast_natAbs
• coe_nat_eq_zero → natCast_eq_zero
• coe_nat_ne_zero → natCast_ne_zero
• coe_nat_ne_zero_iff_pos → natCast_ne_zero_iff_pos
• abs_coe_nat → abs_natCast
• coe_nat_nonpos_iff → natCast_nonpos_iff

Also rename Nat.coe_nat_dvd to Nat.cast_dvd_cast

@@ -328,7 +328,7 @@ lemma intCast_modEq_intCast' {a b : ℤ} {n : ℕ} : a ≡ b [PMOD (n : α)] ↔
 
 @[simp, norm_cast]
 theorem natCast_modEq_natCast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [MOD n] := by
-  simp_rw [← Int.coe_nat_modEq_iff, ← modEq_iff_int_modEq, ← @intCast_modEq_intCast α,
+  simp_rw [← Int.natCast_modEq_iff, ← modEq_iff_int_modEq, ← @intCast_modEq_intCast α,
     Int.cast_ofNat]
 #align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.natCast_modEq_natCast
 

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

@@ -151,7 +151,7 @@ protected theorem of_zsmul : a ≡ b [PMOD z • p] → a ≡ b [PMOD p] := fun
 #align add_comm_group.modeq.of_zsmul AddCommGroup.ModEq.of_zsmul
 
 protected theorem of_nsmul : a ≡ b [PMOD n • p] → a ≡ b [PMOD p] := fun ⟨m, hm⟩ =>
-  ⟨m * n, by rwa [mul_smul, coe_nat_zsmul]⟩
+  ⟨m * n, by rwa [mul_smul, natCast_zsmul]⟩
 #align add_comm_group.modeq.of_nsmul AddCommGroup.ModEq.of_nsmul
 
 protected theorem zsmul : a ≡ b [PMOD p] → z • a ≡ z • b [PMOD z • p] :=

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -222,7 +222,7 @@ alias ⟨sub_left_cancel, sub⟩ := ModEq.sub_iff_left
 alias ⟨sub_right_cancel, _⟩ := ModEq.sub_iff_right
 #align add_comm_group.modeq.sub_right_cancel AddCommGroup.ModEq.sub_right_cancel
 
--- porting note: doesn't work
+-- Porting note: doesn't work
 -- attribute [protected] add_left_cancel add_right_cancel add sub_left_cancel sub_right_cancel sub
 
 protected theorem add_left (c : α) (h : a ≡ b [PMOD p]) : c + a ≡ c + b [PMOD p] :=

Also fix a few misported names.

From LeanAPAP

@@ -317,25 +317,36 @@ section AddCommGroupWithOne
 variable [AddCommGroupWithOne α] [CharZero α]
 
 @[simp, norm_cast]
-theorem int_cast_modEq_int_cast {a b z : ℤ} : a ≡ b [PMOD (z : α)] ↔ a ≡ b [PMOD z] := by
+theorem intCast_modEq_intCast {a b z : ℤ} : a ≡ b [PMOD (z : α)] ↔ a ≡ b [PMOD z] := by
   simp_rw [ModEq, ← Int.cast_mul_eq_zsmul_cast]
   norm_cast
-#align add_comm_group.int_cast_modeq_int_cast AddCommGroup.int_cast_modEq_int_cast
+#align add_comm_group.int_cast_modeq_int_cast AddCommGroup.intCast_modEq_intCast
 
 @[simp, norm_cast]
-theorem nat_cast_modEq_nat_cast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [MOD n] := by
-  simp_rw [← Int.coe_nat_modEq_iff, ← modEq_iff_int_modEq, ← @int_cast_modEq_int_cast α,
+lemma intCast_modEq_intCast' {a b : ℤ} {n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [PMOD (n : ℤ)] := by
+  simpa using intCast_modEq_intCast (α := α) (z := n)
+
+@[simp, norm_cast]
+theorem natCast_modEq_natCast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a ≡ b [MOD n] := by
+  simp_rw [← Int.coe_nat_modEq_iff, ← modEq_iff_int_modEq, ← @intCast_modEq_intCast α,
     Int.cast_ofNat]
-#align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.nat_cast_modEq_nat_cast
+#align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.natCast_modEq_natCast
 
-alias ⟨ModEq.of_int_cast, ModEq.int_cast⟩ := int_cast_modEq_int_cast
-#align add_comm_group.modeq.of_int_cast AddCommGroup.ModEq.of_int_cast
-#align add_comm_group.modeq.int_cast AddCommGroup.ModEq.int_cast
+alias ⟨ModEq.of_intCast, ModEq.intCast⟩ := intCast_modEq_intCast
+#align add_comm_group.modeq.of_int_cast AddCommGroup.ModEq.of_intCast
+#align add_comm_group.modeq.int_cast AddCommGroup.ModEq.intCast
 
-alias ⟨_root_.Nat.ModEq.of_nat_cast, ModEq.nat_cast⟩ := nat_cast_modEq_nat_cast
-#align nat.modeq.of_nat_cast Nat.ModEq.of_nat_cast
-#align add_comm_group.modeq.nat_cast AddCommGroup.ModEq.nat_cast
+alias ⟨_root_.Nat.ModEq.of_natCast, ModEq.natCast⟩ := natCast_modEq_natCast
+#align nat.modeq.of_nat_cast Nat.ModEq.of_natCast
+#align add_comm_group.modeq.nat_cast AddCommGroup.ModEq.natCast
 
 end AddCommGroupWithOne
 
+section DivisionRing
+variable [DivisionRing α] {a b c p : α}
+
+@[simp] lemma div_modEq_div (hc : c ≠ 0) : a / c ≡ b / c [PMOD p] ↔ a ≡ b [PMOD (p * c)] := by
+  simp [ModEq, ← sub_div, div_eq_iff hc, mul_assoc]
+
+end DivisionRing
 end AddCommGroup

Algebra.GroupPower.Lemmas used to be a big bag of lemmas that made it there on the criterion that they needed "more imports". This was completely untrue, as all lemmas could be moved to earlier files in PRs:

• #9440
• #9442
• #9443
• #9455
• #9456
• #9457
• #9459
• #9461
• #9463
• #9466
• #9501
• #9502
• #9503
• #9505
• #9551
• #9553
• #9720
• #9739
• #9740
• #9805
• #9806
• and this one

There are several reasons for this:

• Necessary lemmas have been moved to earlier files since lemmas were dumped in Algebra.GroupPower.Lemmas
• In the Lean 3 → Lean 4 transition, Std acquired basic Int and Nat lemmas which let us shortcircuit the part of the algebraic order hierarchy on which the corresponding general lemmas rest
• Some proofs were overpowered
• Some earlier files were tangled and I have untangled them

This PR finishes the job by moving the last few lemmas out of Algebra.GroupPower.Lemmas, which is therefore deleted.

@@ -3,7 +3,6 @@ Copyright (c) 2023 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
-import Mathlib.Algebra.GroupPower.Lemmas
 import Mathlib.Data.Int.ModEq
 import Mathlib.GroupTheory.QuotientGroup
 

Make all the notations that unambiguously should inherit the docstring of their definition actually inherit it.

Also write a few docstrings by hand. I only wrote the ones I was competent to write and which I was sure of. Some docstrings come from mathlib3 as they were lost during the early port.

This PR is only intended as a first pass There are many more docstrings to add.

@@ -48,6 +48,7 @@ def ModEq (p a b : α) : Prop :=
   ∃ z : ℤ, b - a = z • p
 #align add_comm_group.modeq AddCommGroup.ModEq
 
+@[inherit_doc]
 notation:50 a " ≡ " b " [PMOD " p "]" => ModEq p a b
 
 @[refl, simp]

"congruent modulo a`p`" -> "congruent modulo `p`"

@@ -16,7 +16,7 @@ This file defines equality modulo an element in a commutative group.
 
 ## Main definitions
 
-* `a ≡ b [PMOD p]`: `a` and `b` are congruent modulo a`p`.
+* `a ≡ b [PMOD p]`: `a` and `b` are congruent modulo `p`.
 
 ## See also
 

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>

@@ -3,6 +3,7 @@ Copyright (c) 2023 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
+import Mathlib.Algebra.GroupPower.Lemmas
 import Mathlib.Data.Int.ModEq
 import Mathlib.GroupTheory.QuotientGroup
 

@@ -62,7 +62,7 @@ theorem modEq_comm : a ≡ b [PMOD p] ↔ b ≡ a [PMOD p] :=
   (Equiv.neg _).exists_congr_left.trans <| by simp [ModEq, ← neg_eq_iff_eq_neg]
 #align add_comm_group.modeq_comm AddCommGroup.modEq_comm
 
-alias modEq_comm ↔ ModEq.symm _
+alias ⟨ModEq.symm, _⟩ := modEq_comm
 #align add_comm_group.modeq.symm AddCommGroup.ModEq.symm
 
 attribute [symm] ModEq.symm
@@ -80,7 +80,7 @@ theorem neg_modEq_neg : -a ≡ -b [PMOD p] ↔ a ≡ b [PMOD p] :=
   modEq_comm.trans <| by simp [ModEq, neg_add_eq_sub]
 #align add_comm_group.neg_modeq_neg AddCommGroup.neg_modEq_neg
 
-alias neg_modEq_neg ↔ ModEq.of_neg ModEq.neg
+alias ⟨ModEq.of_neg, ModEq.neg⟩ := neg_modEq_neg
 #align add_comm_group.modeq.of_neg AddCommGroup.ModEq.of_neg
 #align add_comm_group.modeq.neg AddCommGroup.ModEq.neg
 
@@ -89,7 +89,7 @@ theorem modEq_neg : a ≡ b [PMOD -p] ↔ a ≡ b [PMOD p] :=
   modEq_comm.trans <| by simp [ModEq, ← neg_eq_iff_eq_neg]
 #align add_comm_group.modeq_neg AddCommGroup.modEq_neg
 
-alias modEq_neg ↔ ModEq.of_neg' ModEq.neg'
+alias ⟨ModEq.of_neg', ModEq.neg'⟩ := modEq_neg
 #align add_comm_group.modeq.of_neg' AddCommGroup.ModEq.of_neg'
 #align add_comm_group.modeq.neg' AddCommGroup.ModEq.neg'
 
@@ -175,10 +175,10 @@ theorem nsmul_modEq_nsmul [NoZeroSMulDivisors ℕ α] (hn : n ≠ 0) :
   exists_congr fun m => by rw [← smul_sub, smul_comm, smul_right_inj hn]
 #align add_comm_group.nsmul_modeq_nsmul AddCommGroup.nsmul_modEq_nsmul
 
-alias zsmul_modEq_zsmul ↔ ModEq.zsmul_cancel _
+alias ⟨ModEq.zsmul_cancel, _⟩ := zsmul_modEq_zsmul
 #align add_comm_group.modeq.zsmul_cancel AddCommGroup.ModEq.zsmul_cancel
 
-alias nsmul_modEq_nsmul ↔ ModEq.nsmul_cancel _
+alias ⟨ModEq.nsmul_cancel, _⟩ := nsmul_modEq_nsmul
 #align add_comm_group.modeq.nsmul_cancel AddCommGroup.ModEq.nsmul_cancel
 
 namespace ModEq
@@ -207,18 +207,18 @@ protected theorem sub_iff_right :
   (Equiv.subRight m).symm.exists_congr_left.trans <| by simp [sub_sub_sub_comm, hm, sub_smul, ModEq]
 #align add_comm_group.modeq.sub_iff_right AddCommGroup.ModEq.sub_iff_right
 
-alias ModEq.add_iff_left ↔ add_left_cancel add
+alias ⟨add_left_cancel, add⟩ := ModEq.add_iff_left
 #align add_comm_group.modeq.add_left_cancel AddCommGroup.ModEq.add_left_cancel
 #align add_comm_group.modeq.add AddCommGroup.ModEq.add
 
-alias ModEq.add_iff_right ↔ add_right_cancel _
+alias ⟨add_right_cancel, _⟩ := ModEq.add_iff_right
 #align add_comm_group.modeq.add_right_cancel AddCommGroup.ModEq.add_right_cancel
 
-alias ModEq.sub_iff_left ↔ sub_left_cancel sub
+alias ⟨sub_left_cancel, sub⟩ := ModEq.sub_iff_left
 #align add_comm_group.modeq.sub_left_cancel AddCommGroup.ModEq.sub_left_cancel
 #align add_comm_group.modeq.sub AddCommGroup.ModEq.sub
 
-alias ModEq.sub_iff_right ↔ sub_right_cancel _
+alias ⟨sub_right_cancel, _⟩ := ModEq.sub_iff_right
 #align add_comm_group.modeq.sub_right_cancel AddCommGroup.ModEq.sub_right_cancel
 
 -- porting note: doesn't work
@@ -327,11 +327,11 @@ theorem nat_cast_modEq_nat_cast {a b n : ℕ} : a ≡ b [PMOD (n : α)] ↔ a 
     Int.cast_ofNat]
 #align add_comm_group.nat_cast_modeq_nat_cast AddCommGroup.nat_cast_modEq_nat_cast
 
-alias int_cast_modEq_int_cast ↔ ModEq.of_int_cast ModEq.int_cast
+alias ⟨ModEq.of_int_cast, ModEq.int_cast⟩ := int_cast_modEq_int_cast
 #align add_comm_group.modeq.of_int_cast AddCommGroup.ModEq.of_int_cast
 #align add_comm_group.modeq.int_cast AddCommGroup.ModEq.int_cast
 
-alias nat_cast_modEq_nat_cast ↔ _root_.Nat.ModEq.of_nat_cast ModEq.nat_cast
+alias ⟨_root_.Nat.ModEq.of_nat_cast, ModEq.nat_cast⟩ := nat_cast_modEq_nat_cast
 #align nat.modeq.of_nat_cast Nat.ModEq.of_nat_cast
 #align add_comm_group.modeq.nat_cast AddCommGroup.ModEq.nat_cast
 

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

This has nice performance benefits.

@@ -32,7 +32,7 @@ also unify with `Nat.ModEq`.
 
 namespace AddCommGroup
 
-variable {α : Type _}
+variable {α : Type*}
 
 section AddCommGroup
 

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2023 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module algebra.modeq
-! leanprover-community/mathlib commit a07d750983b94c530ab69a726862c2ab6802b38c
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Int.ModEq
 import Mathlib.GroupTheory.QuotientGroup

For now this uses the new command in just one file. If this looks good, I'll make a follow-up to apply this change everywhere.

@@ -11,6 +11,8 @@ Authors: Yaël Dillies
 import Mathlib.Data.Int.ModEq
 import Mathlib.GroupTheory.QuotientGroup
 
+#align_import algebra.modeq from "leanprover-community/mathlib"@"a07d750983b94c530ab69a726862c2ab6802b38c"
+
 /-!
 # Equality modulo an element