algebra.order.sub.defs | Mathlib porting status

Changes since the initial port

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

Changes in mathlib3

de29c328

(last sync)

feat(algebra/order/sub/defs): make has_ordered_sub a Prop (#18810)

has_ordered_sub was incorrectly a Type, because of a Lean 3 bug. This is a backport of mathlib4 [#3436](https://github.com/leanprover-community/mathlib4/pull/3436) .

Co-authored-by: Alex J Best <alex.j.best@gmail.com>

Diff

@@ -52,7 +52,7 @@ In other words, `a - b` is the least `c` such that `a ≤ b + c`.
 This is satisfied both by the subtraction in additive ordered groups and by truncated subtraction
 in canonically ordered monoids on many specific types.
 -/
-class has_ordered_sub (α : Type*) [has_le α] [has_add α] [has_sub α] :=
+class has_ordered_sub (α : Type*) [has_le α] [has_add α] [has_sub α] : Prop :=
 (tsub_le_iff_right : ∀ a b c : α, a - b ≤ c ↔ a ≤ c + b)
 
 section has_add

70d50ecf

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

de29c328

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 -/
-import Mathbin.Algebra.CovariantAndContravariant
-import Mathbin.Algebra.Group.Basic
-import Mathbin.Algebra.Order.Monoid.Lemmas
-import Mathbin.Order.Lattice
+import Algebra.CovariantAndContravariant
+import Algebra.Group.Basic
+import Algebra.Order.Monoid.Lemmas
+import Order.Lattice
 
 #align_import algebra.order.sub.defs from "leanprover-community/mathlib"@"de29c328903507bb7aff506af9135f4bdaf1849c"

de29c328

bump to nightly-2023-08-23-23

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

f612b9e0

Diff

@@ -309,7 +309,7 @@ theorem tsub_nonpos : a - b ≤ 0 ↔ a ≤ b := by rw [tsub_le_iff_left, add_ze
 #align tsub_nonpos tsub_nonpos
 -/
 
-alias tsub_nonpos ↔ _ tsub_nonpos_of_le
+alias ⟨_, tsub_nonpos_of_le⟩ := tsub_nonpos
 #align tsub_nonpos_of_le tsub_nonpos_of_le
 
 end Preorder

de29c328

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
-
-! This file was ported from Lean 3 source module algebra.order.sub.defs
-! leanprover-community/mathlib commit de29c328903507bb7aff506af9135f4bdaf1849c
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.CovariantAndContravariant
 import Mathbin.Algebra.Group.Basic
 import Mathbin.Algebra.Order.Monoid.Lemmas
 import Mathbin.Order.Lattice
 
+#align_import algebra.order.sub.defs from "leanprover-community/mathlib"@"de29c328903507bb7aff506af9135f4bdaf1849c"
+
 /-!
 # Ordered Subtraction

de29c328

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -103,75 +103,106 @@ section AddCommSemigroup
 
 variable [AddCommSemigroup α] [Sub α] [OrderedSub α] {a b c d : α}
 
+#print tsub_le_iff_left /-
 theorem tsub_le_iff_left : a - b ≤ c ↔ a ≤ b + c := by rw [tsub_le_iff_right, add_comm]
 #align tsub_le_iff_left tsub_le_iff_left
+-/
 
+#print le_add_tsub /-
 theorem le_add_tsub : a ≤ b + (a - b) :=
   tsub_le_iff_left.mp le_rfl
 #align le_add_tsub le_add_tsub
+-/
 
+#print add_tsub_le_left /-
 /-- See `add_tsub_cancel_left` for the equality if `contravariant_class α α (+) (≤)`. -/
 theorem add_tsub_le_left : a + b - a ≤ b :=
   tsub_le_iff_left.mpr le_rfl
 #align add_tsub_le_left add_tsub_le_left
+-/
 
+#print tsub_le_tsub_right /-
 theorem tsub_le_tsub_right (h : a ≤ b) (c : α) : a - c ≤ b - c :=
   tsub_le_iff_left.mpr <| h.trans le_add_tsub
 #align tsub_le_tsub_right tsub_le_tsub_right
+-/
 
+#print tsub_le_iff_tsub_le /-
 theorem tsub_le_iff_tsub_le : a - b ≤ c ↔ a - c ≤ b := by rw [tsub_le_iff_left, tsub_le_iff_right]
 #align tsub_le_iff_tsub_le tsub_le_iff_tsub_le
+-/
 
+#print tsub_tsub_le /-
 /-- See `tsub_tsub_cancel_of_le` for the equality. -/
 theorem tsub_tsub_le : b - (b - a) ≤ a :=
   tsub_le_iff_right.mpr le_add_tsub
 #align tsub_tsub_le tsub_tsub_le
+-/
 
 section Cov
 
 variable [CovariantClass α α (· + ·) (· ≤ ·)]
 
+#print tsub_le_tsub_left /-
 theorem tsub_le_tsub_left (h : a ≤ b) (c : α) : c - b ≤ c - a :=
   tsub_le_iff_left.mpr <| le_add_tsub.trans <| add_le_add_right h _
 #align tsub_le_tsub_left tsub_le_tsub_left
+-/
 
+#print tsub_le_tsub /-
 theorem tsub_le_tsub (hab : a ≤ b) (hcd : c ≤ d) : a - d ≤ b - c :=
   (tsub_le_tsub_right hab _).trans <| tsub_le_tsub_left hcd _
 #align tsub_le_tsub tsub_le_tsub
+-/
 
+#print antitone_const_tsub /-
 theorem antitone_const_tsub : Antitone fun x => c - x := fun x y hxy => tsub_le_tsub rfl.le hxy
 #align antitone_const_tsub antitone_const_tsub
+-/
 
+#print add_tsub_le_assoc /-
 /-- See `add_tsub_assoc_of_le` for the equality. -/
 theorem add_tsub_le_assoc : a + b - c ≤ a + (b - c) := by rw [tsub_le_iff_left, add_left_comm];
   exact add_le_add_left le_add_tsub a
 #align add_tsub_le_assoc add_tsub_le_assoc
+-/
 
+#print add_tsub_le_tsub_add /-
 /-- See `tsub_add_eq_add_tsub` for the equality. -/
 theorem add_tsub_le_tsub_add : a + b - c ≤ a - c + b := by rw [add_comm, add_comm _ b];
   exact add_tsub_le_assoc
 #align add_tsub_le_tsub_add add_tsub_le_tsub_add
+-/
 
+#print add_le_add_add_tsub /-
 theorem add_le_add_add_tsub : a + b ≤ a + c + (b - c) := by rw [add_assoc];
   exact add_le_add_left le_add_tsub a
 #align add_le_add_add_tsub add_le_add_add_tsub
+-/
 
+#print le_tsub_add_add /-
 theorem le_tsub_add_add : a + b ≤ a - c + (b + c) := by rw [add_comm a, add_comm (a - c)];
   exact add_le_add_add_tsub
 #align le_tsub_add_add le_tsub_add_add
+-/
 
+#print tsub_le_tsub_add_tsub /-
 theorem tsub_le_tsub_add_tsub : a - c ≤ a - b + (b - c) :=
   by
   rw [tsub_le_iff_left, ← add_assoc, add_right_comm]
   exact le_add_tsub.trans (add_le_add_right le_add_tsub _)
 #align tsub_le_tsub_add_tsub tsub_le_tsub_add_tsub
+-/
 
+#print tsub_tsub_tsub_le_tsub /-
 theorem tsub_tsub_tsub_le_tsub : c - a - (c - b) ≤ b - a :=
   by
   rw [tsub_le_iff_left, tsub_le_iff_left, add_left_comm]
   exact le_tsub_add.trans (add_le_add_left le_add_tsub _)
 #align tsub_tsub_tsub_le_tsub tsub_tsub_tsub_le_tsub
+-/
 
+#print tsub_tsub_le_tsub_add /-
 theorem tsub_tsub_le_tsub_add {a b c : α} : a - (b - c) ≤ a - b + c :=
   tsub_le_iff_right.2 <|
     calc
@@ -179,7 +210,9 @@ theorem tsub_tsub_le_tsub_add {a b c : α} : a - (b - c) ≤ a - b + c :=
       _ ≤ a - b + (c + (b - c)) := (add_le_add_left le_add_tsub _)
       _ = a - b + c + (b - c) := (add_assoc _ _ _).symm
 #align tsub_tsub_le_tsub_add tsub_tsub_le_tsub_add
+-/
 
+#print add_tsub_add_le_tsub_add_tsub /-
 /-- See `tsub_add_tsub_comm` for the equality. -/
 theorem add_tsub_add_le_tsub_add_tsub : a + b - (c + d) ≤ a - c + (b - d) :=
   by
@@ -188,16 +221,21 @@ theorem add_tsub_add_le_tsub_add_tsub : a + b - (c + d) ≤ a - c + (b - d) :=
   rw [add_comm a, add_comm (a - c)]
   exact add_tsub_le_assoc
 #align add_tsub_add_le_tsub_add_tsub add_tsub_add_le_tsub_add_tsub
+-/
 
+#print add_tsub_add_le_tsub_left /-
 /-- See `add_tsub_add_eq_tsub_left` for the equality. -/
 theorem add_tsub_add_le_tsub_left : a + b - (a + c) ≤ b - c := by rw [tsub_le_iff_left, add_assoc];
   exact add_le_add_left le_add_tsub _
 #align add_tsub_add_le_tsub_left add_tsub_add_le_tsub_left
+-/
 
+#print add_tsub_add_le_tsub_right /-
 /-- See `add_tsub_add_eq_tsub_right` for the equality. -/
 theorem add_tsub_add_le_tsub_right : a + c - (b + c) ≤ a - b := by
   rw [tsub_le_iff_left, add_right_comm]; exact add_le_add_right le_add_tsub c
 #align add_tsub_add_le_tsub_right add_tsub_add_le_tsub_right
+-/
 
 end Cov
 
@@ -206,21 +244,29 @@ end Cov
 
 namespace AddLECancellable
 
+#print AddLECancellable.le_add_tsub_swap /-
 protected theorem le_add_tsub_swap (hb : AddLECancellable b) : a ≤ b + a - b :=
   hb le_add_tsub
 #align add_le_cancellable.le_add_tsub_swap AddLECancellable.le_add_tsub_swap
+-/
 
+#print AddLECancellable.le_add_tsub /-
 protected theorem le_add_tsub (hb : AddLECancellable b) : a ≤ a + b - b := by rw [add_comm];
   exact hb.le_add_tsub_swap
 #align add_le_cancellable.le_add_tsub AddLECancellable.le_add_tsub
+-/
 
+#print AddLECancellable.le_tsub_of_add_le_left /-
 protected theorem le_tsub_of_add_le_left (ha : AddLECancellable a) (h : a + b ≤ c) : b ≤ c - a :=
   ha <| h.trans le_add_tsub
 #align add_le_cancellable.le_tsub_of_add_le_left AddLECancellable.le_tsub_of_add_le_left
+-/
 
+#print AddLECancellable.le_tsub_of_add_le_right /-
 protected theorem le_tsub_of_add_le_right (hb : AddLECancellable b) (h : a + b ≤ c) : a ≤ c - b :=
   hb.le_tsub_of_add_le_left <| by rwa [add_comm]
 #align add_le_cancellable.le_tsub_of_add_le_right AddLECancellable.le_tsub_of_add_le_right
+-/
 
 end AddLECancellable
 
@@ -231,21 +277,29 @@ section Contra
 
 variable [ContravariantClass α α (· + ·) (· ≤ ·)]
 
+#print le_add_tsub_swap /-
 theorem le_add_tsub_swap : a ≤ b + a - b :=
   Contravariant.AddLECancellable.le_add_tsub_swap
 #align le_add_tsub_swap le_add_tsub_swap
+-/
 
+#print le_add_tsub' /-
 theorem le_add_tsub' : a ≤ a + b - b :=
   Contravariant.AddLECancellable.le_add_tsub
 #align le_add_tsub' le_add_tsub'
+-/
 
+#print le_tsub_of_add_le_left /-
 theorem le_tsub_of_add_le_left (h : a + b ≤ c) : b ≤ c - a :=
   Contravariant.AddLECancellable.le_tsub_of_add_le_left h
 #align le_tsub_of_add_le_left le_tsub_of_add_le_left
+-/
 
+#print le_tsub_of_add_le_right /-
 theorem le_tsub_of_add_le_right (h : a + b ≤ c) : a ≤ c - b :=
   Contravariant.AddLECancellable.le_tsub_of_add_le_right h
 #align le_tsub_of_add_le_right le_tsub_of_add_le_right
+-/
 
 end Contra
 
@@ -253,8 +307,10 @@ end AddCommSemigroup
 
 variable [AddCommMonoid α] [Sub α] [OrderedSub α] {a b c d : α}
 
+#print tsub_nonpos /-
 theorem tsub_nonpos : a - b ≤ 0 ↔ a ≤ b := by rw [tsub_le_iff_left, add_zero]
 #align tsub_nonpos tsub_nonpos
+-/
 
 alias tsub_nonpos ↔ _ tsub_nonpos_of_le
 #align tsub_nonpos_of_le tsub_nonpos_of_le
@@ -266,51 +322,70 @@ end Preorder
 
 variable [PartialOrder α] [AddCommSemigroup α] [Sub α] [OrderedSub α] {a b c d : α}
 
+#print tsub_tsub /-
 theorem tsub_tsub (b a c : α) : b - a - c = b - (a + c) :=
   by
   apply le_antisymm
   · rw [tsub_le_iff_left, tsub_le_iff_left, ← add_assoc, ← tsub_le_iff_left]
   · rw [tsub_le_iff_left, add_assoc, ← tsub_le_iff_left, ← tsub_le_iff_left]
 #align tsub_tsub tsub_tsub
+-/
 
+#print tsub_add_eq_tsub_tsub /-
 theorem tsub_add_eq_tsub_tsub (a b c : α) : a - (b + c) = a - b - c :=
   (tsub_tsub _ _ _).symm
 #align tsub_add_eq_tsub_tsub tsub_add_eq_tsub_tsub
+-/
 
+#print tsub_add_eq_tsub_tsub_swap /-
 theorem tsub_add_eq_tsub_tsub_swap (a b c : α) : a - (b + c) = a - c - b := by rw [add_comm];
   apply tsub_add_eq_tsub_tsub
 #align tsub_add_eq_tsub_tsub_swap tsub_add_eq_tsub_tsub_swap
+-/
 
+#print tsub_right_comm /-
 theorem tsub_right_comm : a - b - c = a - c - b := by simp_rw [← tsub_add_eq_tsub_tsub, add_comm]
 #align tsub_right_comm tsub_right_comm
+-/
 
 /-! ### Lemmas that assume that an element is `add_le_cancellable`. -/
 
 
 namespace AddLECancellable
 
+#print AddLECancellable.tsub_eq_of_eq_add /-
 protected theorem tsub_eq_of_eq_add (hb : AddLECancellable b) (h : a = c + b) : a - b = c :=
   le_antisymm (tsub_le_iff_right.mpr h.le) <| by rw [h]; exact hb.le_add_tsub
 #align add_le_cancellable.tsub_eq_of_eq_add AddLECancellable.tsub_eq_of_eq_add
+-/
 
+#print AddLECancellable.eq_tsub_of_add_eq /-
 protected theorem eq_tsub_of_add_eq (hc : AddLECancellable c) (h : a + c = b) : a = b - c :=
   (hc.tsub_eq_of_eq_add h.symm).symm
 #align add_le_cancellable.eq_tsub_of_add_eq AddLECancellable.eq_tsub_of_add_eq
+-/
 
+#print AddLECancellable.tsub_eq_of_eq_add_rev /-
 protected theorem tsub_eq_of_eq_add_rev (hb : AddLECancellable b) (h : a = b + c) : a - b = c :=
   hb.tsub_eq_of_eq_add <| by rw [add_comm, h]
 #align add_le_cancellable.tsub_eq_of_eq_add_rev AddLECancellable.tsub_eq_of_eq_add_rev
+-/
 
+#print AddLECancellable.add_tsub_cancel_right /-
 @[simp]
 protected theorem add_tsub_cancel_right (hb : AddLECancellable b) : a + b - b = a :=
   hb.tsub_eq_of_eq_add <| by rw [add_comm]
 #align add_le_cancellable.add_tsub_cancel_right AddLECancellable.add_tsub_cancel_right
+-/
 
+#print AddLECancellable.add_tsub_cancel_left /-
 @[simp]
 protected theorem add_tsub_cancel_left (ha : AddLECancellable a) : a + b - a = b :=
   ha.tsub_eq_of_eq_add <| add_comm a b
 #align add_le_cancellable.add_tsub_cancel_left AddLECancellable.add_tsub_cancel_left
+-/
 
+#print AddLECancellable.lt_add_of_tsub_lt_left /-
 protected theorem lt_add_of_tsub_lt_left (hb : AddLECancellable b) (h : a - b < c) : a < b + c :=
   by
   rw [lt_iff_le_and_ne, ← tsub_le_iff_left]
@@ -318,7 +393,9 @@ protected theorem lt_add_of_tsub_lt_left (hb : AddLECancellable b) (h : a - b <
   rintro rfl
   simpa [hb] using h
 #align add_le_cancellable.lt_add_of_tsub_lt_left AddLECancellable.lt_add_of_tsub_lt_left
+-/
 
+#print AddLECancellable.lt_add_of_tsub_lt_right /-
 protected theorem lt_add_of_tsub_lt_right (hc : AddLECancellable c) (h : a - c < b) : a < b + c :=
   by
   rw [lt_iff_le_and_ne, ← tsub_le_iff_right]
@@ -326,14 +403,19 @@ protected theorem lt_add_of_tsub_lt_right (hc : AddLECancellable c) (h : a - c <
   rintro rfl
   simpa [hc] using h
 #align add_le_cancellable.lt_add_of_tsub_lt_right AddLECancellable.lt_add_of_tsub_lt_right
+-/
 
+#print AddLECancellable.lt_tsub_of_add_lt_right /-
 protected theorem lt_tsub_of_add_lt_right (hc : AddLECancellable c) (h : a + c < b) : a < b - c :=
   (hc.le_tsub_of_add_le_right h.le).lt_of_ne <| by rintro rfl; exact h.not_le le_tsub_add
 #align add_le_cancellable.lt_tsub_of_add_lt_right AddLECancellable.lt_tsub_of_add_lt_right
+-/
 
+#print AddLECancellable.lt_tsub_of_add_lt_left /-
 protected theorem lt_tsub_of_add_lt_left (ha : AddLECancellable a) (h : a + c < b) : c < b - a :=
   ha.lt_tsub_of_add_lt_right <| by rwa [add_comm]
 #align add_le_cancellable.lt_tsub_of_add_lt_left AddLECancellable.lt_tsub_of_add_lt_left
+-/
 
 end AddLECancellable
 
@@ -344,45 +426,63 @@ section Contra
 
 variable [ContravariantClass α α (· + ·) (· ≤ ·)]
 
+#print tsub_eq_of_eq_add /-
 theorem tsub_eq_of_eq_add (h : a = c + b) : a - b = c :=
   Contravariant.AddLECancellable.tsub_eq_of_eq_add h
 #align tsub_eq_of_eq_add tsub_eq_of_eq_add
+-/
 
+#print eq_tsub_of_add_eq /-
 theorem eq_tsub_of_add_eq (h : a + c = b) : a = b - c :=
   Contravariant.AddLECancellable.eq_tsub_of_add_eq h
 #align eq_tsub_of_add_eq eq_tsub_of_add_eq
+-/
 
+#print tsub_eq_of_eq_add_rev /-
 theorem tsub_eq_of_eq_add_rev (h : a = b + c) : a - b = c :=
   Contravariant.AddLECancellable.tsub_eq_of_eq_add_rev h
 #align tsub_eq_of_eq_add_rev tsub_eq_of_eq_add_rev
+-/
 
+#print add_tsub_cancel_right /-
 @[simp]
 theorem add_tsub_cancel_right (a b : α) : a + b - b = a :=
   Contravariant.AddLECancellable.add_tsub_cancel_right
 #align add_tsub_cancel_right add_tsub_cancel_right
+-/
 
+#print add_tsub_cancel_left /-
 @[simp]
 theorem add_tsub_cancel_left (a b : α) : a + b - a = b :=
   Contravariant.AddLECancellable.add_tsub_cancel_left
 #align add_tsub_cancel_left add_tsub_cancel_left
+-/
 
+#print lt_add_of_tsub_lt_left /-
 theorem lt_add_of_tsub_lt_left (h : a - b < c) : a < b + c :=
   Contravariant.AddLECancellable.lt_add_of_tsub_lt_left h
 #align lt_add_of_tsub_lt_left lt_add_of_tsub_lt_left
+-/
 
+#print lt_add_of_tsub_lt_right /-
 theorem lt_add_of_tsub_lt_right (h : a - c < b) : a < b + c :=
   Contravariant.AddLECancellable.lt_add_of_tsub_lt_right h
 #align lt_add_of_tsub_lt_right lt_add_of_tsub_lt_right
+-/
 
+#print lt_tsub_of_add_lt_left /-
 /-- This lemma (and some of its corollaries) also holds for `ennreal`, but this proof doesn't work
 for it. Maybe we should add this lemma as field to `has_ordered_sub`? -/
 theorem lt_tsub_of_add_lt_left : a + c < b → c < b - a :=
   Contravariant.AddLECancellable.lt_tsub_of_add_lt_left
 #align lt_tsub_of_add_lt_left lt_tsub_of_add_lt_left
+-/
 
+#print lt_tsub_of_add_lt_right /-
 theorem lt_tsub_of_add_lt_right : a + c < b → a < b - c :=
   Contravariant.AddLECancellable.lt_tsub_of_add_lt_right
 #align lt_tsub_of_add_lt_right lt_tsub_of_add_lt_right
+-/
 
 end Contra
 
@@ -390,6 +490,7 @@ section Both
 
 variable [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)]
 
+#print add_tsub_add_eq_tsub_right /-
 theorem add_tsub_add_eq_tsub_right (a c b : α) : a + c - (b + c) = a - b :=
   by
   refine' add_tsub_add_le_tsub_right.antisymm (tsub_le_iff_right.2 <| le_of_add_le_add_right _);
@@ -397,10 +498,13 @@ theorem add_tsub_add_eq_tsub_right (a c b : α) : a + c - (b + c) = a - b :=
   rw [add_assoc]
   exact le_tsub_add
 #align add_tsub_add_eq_tsub_right add_tsub_add_eq_tsub_right
+-/
 
+#print add_tsub_add_eq_tsub_left /-
 theorem add_tsub_add_eq_tsub_left (a b c : α) : a + b - (a + c) = b - c := by
   rw [add_comm a b, add_comm a c, add_tsub_add_eq_tsub_right]
 #align add_tsub_add_eq_tsub_left add_tsub_add_eq_tsub_left
+-/
 
 end Both
 
@@ -413,33 +517,43 @@ section LinearOrder
 
 variable {a b c d : α} [LinearOrder α] [AddCommSemigroup α] [Sub α] [OrderedSub α]
 
+#print lt_of_tsub_lt_tsub_right /-
 /-- See `lt_of_tsub_lt_tsub_right_of_le` for a weaker statement in a partial order. -/
 theorem lt_of_tsub_lt_tsub_right (h : a - c < b - c) : a < b :=
   lt_imp_lt_of_le_imp_le (fun h => tsub_le_tsub_right h c) h
 #align lt_of_tsub_lt_tsub_right lt_of_tsub_lt_tsub_right
+-/
 
+#print lt_tsub_iff_right /-
 /-- See `lt_tsub_iff_right_of_le` for a weaker statement in a partial order. -/
 theorem lt_tsub_iff_right : a < b - c ↔ a + c < b :=
   lt_iff_lt_of_le_iff_le tsub_le_iff_right
 #align lt_tsub_iff_right lt_tsub_iff_right
+-/
 
+#print lt_tsub_iff_left /-
 /-- See `lt_tsub_iff_left_of_le` for a weaker statement in a partial order. -/
 theorem lt_tsub_iff_left : a < b - c ↔ c + a < b :=
   lt_iff_lt_of_le_iff_le tsub_le_iff_left
 #align lt_tsub_iff_left lt_tsub_iff_left
+-/
 
+#print lt_tsub_comm /-
 theorem lt_tsub_comm : a < b - c ↔ c < b - a :=
   lt_tsub_iff_left.trans lt_tsub_iff_right.symm
 #align lt_tsub_comm lt_tsub_comm
+-/
 
 section Cov
 
 variable [CovariantClass α α (· + ·) (· ≤ ·)]
 
+#print lt_of_tsub_lt_tsub_left /-
 /-- See `lt_of_tsub_lt_tsub_left_of_le` for a weaker statement in a partial order. -/
 theorem lt_of_tsub_lt_tsub_left (h : a - b < a - c) : c < b :=
   lt_imp_lt_of_le_imp_le (fun h => tsub_le_tsub_left h a) h
 #align lt_of_tsub_lt_tsub_left lt_of_tsub_lt_tsub_left
+-/
 
 end Cov
 
@@ -449,10 +563,12 @@ section OrderedAddCommMonoid
 
 variable [PartialOrder α] [AddCommMonoid α] [Sub α] [OrderedSub α]
 
+#print tsub_zero /-
 @[simp]
 theorem tsub_zero (a : α) : a - 0 = a :=
   AddLECancellable.tsub_eq_of_eq_add addLECancellable_zero (add_zero _).symm
 #align tsub_zero tsub_zero
+-/
 
 end OrderedAddCommMonoid

de29c328

bump to nightly-2023-06-09-07

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

16afdc39

Diff

@@ -178,7 +178,6 @@ theorem tsub_tsub_le_tsub_add {a b c : α} : a - (b - c) ≤ a - b + c :=
       a ≤ a - b + b := le_tsub_add
       _ ≤ a - b + (c + (b - c)) := (add_le_add_left le_add_tsub _)
       _ = a - b + c + (b - c) := (add_assoc _ _ _).symm
-      
 #align tsub_tsub_le_tsub_add tsub_tsub_le_tsub_add
 
 /-- See `tsub_add_tsub_comm` for the equality. -/

de29c328

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -68,19 +68,25 @@ section Add
 
 variable [Preorder α] [Add α] [Sub α] [OrderedSub α] {a b c d : α}
 
+#print tsub_le_iff_right /-
 @[simp]
 theorem tsub_le_iff_right : a - b ≤ c ↔ a ≤ c + b :=
   OrderedSub.tsub_le_iff_right a b c
 #align tsub_le_iff_right tsub_le_iff_right
+-/
 
+#print add_tsub_le_right /-
 /-- See `add_tsub_cancel_right` for the equality if `contravariant_class α α (+) (≤)`. -/
 theorem add_tsub_le_right : a + b - b ≤ a :=
   tsub_le_iff_right.mpr le_rfl
 #align add_tsub_le_right add_tsub_le_right
+-/
 
+#print le_tsub_add /-
 theorem le_tsub_add : b ≤ b - a + a :=
   tsub_le_iff_right.mp le_rfl
 #align le_tsub_add le_tsub_add
+-/
 
 end Add

de29c328

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -68,34 +68,16 @@ section Add
 
 variable [Preorder α] [Add α] [Sub α] [OrderedSub α] {a b c d : α}
 
-/- warning: tsub_le_iff_right -> tsub_le_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) c b))
-Case conversion may be inaccurate. Consider using '#align tsub_le_iff_right tsub_le_iff_rightₓ'. -/
 @[simp]
 theorem tsub_le_iff_right : a - b ≤ c ↔ a ≤ c + b :=
   OrderedSub.tsub_le_iff_right a b c
 #align tsub_le_iff_right tsub_le_iff_right
 
-/- warning: add_tsub_le_right -> add_tsub_le_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) a b) b) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) a b) b) a
-Case conversion may be inaccurate. Consider using '#align add_tsub_le_right add_tsub_le_rightₓ'. -/
 /-- See `add_tsub_cancel_right` for the equality if `contravariant_class α α (+) (≤)`. -/
 theorem add_tsub_le_right : a + b - b ≤ a :=
   tsub_le_iff_right.mpr le_rfl
 #align add_tsub_le_right add_tsub_le_right
 
-/- warning: le_tsub_add -> le_tsub_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a) a)
-Case conversion may be inaccurate. Consider using '#align le_tsub_add le_tsub_addₓ'. -/
 theorem le_tsub_add : b ≤ b - a + a :=
   tsub_le_iff_right.mp le_rfl
 #align le_tsub_add le_tsub_add
@@ -115,61 +97,25 @@ section AddCommSemigroup
 
 variable [AddCommSemigroup α] [Sub α] [OrderedSub α] {a b c d : α}
 
-/- warning: tsub_le_iff_left -> tsub_le_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-Case conversion may be inaccurate. Consider using '#align tsub_le_iff_left tsub_le_iff_leftₓ'. -/
 theorem tsub_le_iff_left : a - b ≤ c ↔ a ≤ b + c := by rw [tsub_le_iff_right, add_comm]
 #align tsub_le_iff_left tsub_le_iff_left
 
-/- warning: le_add_tsub -> le_add_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b))
-Case conversion may be inaccurate. Consider using '#align le_add_tsub le_add_tsubₓ'. -/
 theorem le_add_tsub : a ≤ b + (a - b) :=
   tsub_le_iff_left.mp le_rfl
 #align le_add_tsub le_add_tsub
 
-/- warning: add_tsub_le_left -> add_tsub_le_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b
-Case conversion may be inaccurate. Consider using '#align add_tsub_le_left add_tsub_le_leftₓ'. -/
 /-- See `add_tsub_cancel_left` for the equality if `contravariant_class α α (+) (≤)`. -/
 theorem add_tsub_le_left : a + b - a ≤ b :=
   tsub_le_iff_left.mpr le_rfl
 #align add_tsub_le_left add_tsub_le_left
 
-/- warning: tsub_le_tsub_right -> tsub_le_tsub_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (forall (c : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (forall (c : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align tsub_le_tsub_right tsub_le_tsub_rightₓ'. -/
 theorem tsub_le_tsub_right (h : a ≤ b) (c : α) : a - c ≤ b - c :=
   tsub_le_iff_left.mpr <| h.trans le_add_tsub
 #align tsub_le_tsub_right tsub_le_tsub_right
 
-/- warning: tsub_le_iff_tsub_le -> tsub_le_iff_tsub_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
-Case conversion may be inaccurate. Consider using '#align tsub_le_iff_tsub_le tsub_le_iff_tsub_leₓ'. -/
 theorem tsub_le_iff_tsub_le : a - b ≤ c ↔ a - c ≤ b := by rw [tsub_le_iff_left, tsub_le_iff_right]
 #align tsub_le_iff_tsub_le tsub_le_iff_tsub_le
 
-/- warning: tsub_tsub_le -> tsub_tsub_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a)) a
-Case conversion may be inaccurate. Consider using '#align tsub_tsub_le tsub_tsub_leₓ'. -/
 /-- See `tsub_tsub_cancel_of_le` for the equality. -/
 theorem tsub_tsub_le : b - (b - a) ≤ a :=
   tsub_le_iff_right.mpr le_add_tsub
@@ -179,107 +125,47 @@ section Cov
 
 variable [CovariantClass α α (· + ·) (· ≤ ·)]
 
-/- warning: tsub_le_tsub_left -> tsub_le_tsub_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (forall (c : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.564 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.566 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.564 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.566) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.579 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.581 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.579 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.581)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (forall (c : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
-Case conversion may be inaccurate. Consider using '#align tsub_le_tsub_left tsub_le_tsub_leftₓ'. -/
 theorem tsub_le_tsub_left (h : a ≤ b) (c : α) : c - b ≤ c - a :=
   tsub_le_iff_left.mpr <| le_add_tsub.trans <| add_le_add_right h _
 #align tsub_le_tsub_left tsub_le_tsub_left
 
-/- warning: tsub_le_tsub -> tsub_le_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} {d : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a d) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} {d : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.642 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.644 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.642 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.644) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.657 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.659 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.657 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.659)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a d) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align tsub_le_tsub tsub_le_tsubₓ'. -/
 theorem tsub_le_tsub (hab : a ≤ b) (hcd : c ≤ d) : a - d ≤ b - c :=
   (tsub_le_tsub_right hab _).trans <| tsub_le_tsub_left hcd _
 #align tsub_le_tsub tsub_le_tsub
 
-/- warning: antitone_const_tsub -> antitone_const_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], Antitone.{u1, u1} α α _inst_1 _inst_1 (fun (x : α) => HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c x)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.726 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.728 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.726 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.728) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.741 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.743 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.741 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.743)], Antitone.{u1, u1} α α _inst_1 _inst_1 (fun (x : α) => HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c x)
-Case conversion may be inaccurate. Consider using '#align antitone_const_tsub antitone_const_tsubₓ'. -/
 theorem antitone_const_tsub : Antitone fun x => c - x := fun x y hxy => tsub_le_tsub rfl.le hxy
 #align antitone_const_tsub antitone_const_tsub
 
-/- warning: add_tsub_le_assoc -> add_tsub_le_assoc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.799 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.801 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.799 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.801) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.814 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.816 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.814 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.816)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align add_tsub_le_assoc add_tsub_le_assocₓ'. -/
 /-- See `add_tsub_assoc_of_le` for the equality. -/
 theorem add_tsub_le_assoc : a + b - c ≤ a + (b - c) := by rw [tsub_le_iff_left, add_left_comm];
   exact add_le_add_left le_add_tsub a
 #align add_tsub_le_assoc add_tsub_le_assoc
 
-/- warning: add_tsub_le_tsub_add -> add_tsub_le_tsub_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.903 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.905 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.903 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.905) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.918 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.920 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.918 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.920)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
-Case conversion may be inaccurate. Consider using '#align add_tsub_le_tsub_add add_tsub_le_tsub_addₓ'. -/
 /-- See `tsub_add_eq_add_tsub` for the equality. -/
 theorem add_tsub_le_tsub_add : a + b - c ≤ a - c + b := by rw [add_comm, add_comm _ b];
   exact add_tsub_le_assoc
 #align add_tsub_le_tsub_add add_tsub_le_tsub_add
 
-/- warning: add_le_add_add_tsub -> add_le_add_add_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1007 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1009 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1007 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1009) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1022 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1024 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1022 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1024)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align add_le_add_add_tsub add_le_add_add_tsubₓ'. -/
 theorem add_le_add_add_tsub : a + b ≤ a + c + (b - c) := by rw [add_assoc];
   exact add_le_add_left le_add_tsub a
 #align add_le_add_add_tsub add_le_add_add_tsub
 
-/- warning: le_tsub_add_add -> le_tsub_add_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1110 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1112 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1110 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1112) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1125 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1127 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1125 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1127)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-Case conversion may be inaccurate. Consider using '#align le_tsub_add_add le_tsub_add_addₓ'. -/
 theorem le_tsub_add_add : a + b ≤ a - c + (b + c) := by rw [add_comm a, add_comm (a - c)];
   exact add_le_add_add_tsub
 #align le_tsub_add_add le_tsub_add_add
 
-/- warning: tsub_le_tsub_add_tsub -> tsub_le_tsub_add_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1220 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1222 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1220 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1222) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1235 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1237 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1235 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1237)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align tsub_le_tsub_add_tsub tsub_le_tsub_add_tsubₓ'. -/
 theorem tsub_le_tsub_add_tsub : a - c ≤ a - b + (b - c) :=
   by
   rw [tsub_le_iff_left, ← add_assoc, add_right_comm]
   exact le_add_tsub.trans (add_le_add_right le_add_tsub _)
 #align tsub_le_tsub_add_tsub tsub_le_tsub_add_tsub
 
-/- warning: tsub_tsub_tsub_le_tsub -> tsub_tsub_tsub_le_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1328 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1330 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1328 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1330) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1343 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1345 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1343 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1345)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a)
-Case conversion may be inaccurate. Consider using '#align tsub_tsub_tsub_le_tsub tsub_tsub_tsub_le_tsubₓ'. -/
 theorem tsub_tsub_tsub_le_tsub : c - a - (c - b) ≤ b - a :=
   by
   rw [tsub_le_iff_left, tsub_le_iff_left, add_left_comm]
   exact le_tsub_add.trans (add_le_add_left le_add_tsub _)
 #align tsub_tsub_tsub_le_tsub tsub_tsub_tsub_le_tsub
 
-/- warning: tsub_tsub_le_tsub_add -> tsub_tsub_le_tsub_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))] {a : α} {b : α} {c : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1436 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1438 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1436 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1438) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1451 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1453 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1451 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1453)] {a : α} {b : α} {c : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-Case conversion may be inaccurate. Consider using '#align tsub_tsub_le_tsub_add tsub_tsub_le_tsub_addₓ'. -/
 theorem tsub_tsub_le_tsub_add {a b c : α} : a - (b - c) ≤ a - b + c :=
   tsub_le_iff_right.2 <|
     calc
@@ -289,12 +175,6 @@ theorem tsub_tsub_le_tsub_add {a b c : α} : a - (b - c) ≤ a - b + c :=
       
 #align tsub_tsub_le_tsub_add tsub_tsub_le_tsub_add
 
-/- warning: add_tsub_add_le_tsub_add_tsub -> add_tsub_add_le_tsub_add_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} {d : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c d)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b d))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} {d : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1575 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1577 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1575 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1577) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1590 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1592 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1590 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1592)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c d)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b d))
-Case conversion may be inaccurate. Consider using '#align add_tsub_add_le_tsub_add_tsub add_tsub_add_le_tsub_add_tsubₓ'. -/
 /-- See `tsub_add_tsub_comm` for the equality. -/
 theorem add_tsub_add_le_tsub_add_tsub : a + b - (c + d) ≤ a - c + (b - d) :=
   by
@@ -304,23 +184,11 @@ theorem add_tsub_add_le_tsub_add_tsub : a + b - (c + d) ≤ a - c + (b - d) :=
   exact add_tsub_le_assoc
 #align add_tsub_add_le_tsub_add_tsub add_tsub_add_le_tsub_add_tsub
 
-/- warning: add_tsub_add_le_tsub_left -> add_tsub_add_le_tsub_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1731 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1733 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1731 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1733) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1746 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1748 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1746 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1748)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align add_tsub_add_le_tsub_left add_tsub_add_le_tsub_leftₓ'. -/
 /-- See `add_tsub_add_eq_tsub_left` for the equality. -/
 theorem add_tsub_add_le_tsub_left : a + b - (a + c) ≤ b - c := by rw [tsub_le_iff_left, add_assoc];
   exact add_le_add_left le_add_tsub _
 #align add_tsub_add_le_tsub_left add_tsub_add_le_tsub_left
 
-/- warning: add_tsub_add_le_tsub_right -> add_tsub_add_le_tsub_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1835 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1837 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1835 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1837) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1850 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1852 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1850 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1852)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
-Case conversion may be inaccurate. Consider using '#align add_tsub_add_le_tsub_right add_tsub_add_le_tsub_rightₓ'. -/
 /-- See `add_tsub_add_eq_tsub_right` for the equality. -/
 theorem add_tsub_add_le_tsub_right : a + c - (b + c) ≤ a - b := by
   rw [tsub_le_iff_left, add_right_comm]; exact add_le_add_right le_add_tsub c
@@ -333,42 +201,18 @@ end Cov
 
 namespace AddLECancellable
 
-/- warning: add_le_cancellable.le_add_tsub_swap -> AddLECancellable.le_add_tsub_swap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b a) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b a) b))
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.le_add_tsub_swap AddLECancellable.le_add_tsub_swapₓ'. -/
 protected theorem le_add_tsub_swap (hb : AddLECancellable b) : a ≤ b + a - b :=
   hb le_add_tsub
 #align add_le_cancellable.le_add_tsub_swap AddLECancellable.le_add_tsub_swap
 
-/- warning: add_le_cancellable.le_add_tsub -> AddLECancellable.le_add_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b))
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.le_add_tsub AddLECancellable.le_add_tsubₓ'. -/
 protected theorem le_add_tsub (hb : AddLECancellable b) : a ≤ a + b - b := by rw [add_comm];
   exact hb.le_add_tsub_swap
 #align add_le_cancellable.le_add_tsub AddLECancellable.le_add_tsub
 
-/- warning: add_le_cancellable.le_tsub_of_add_le_left -> AddLECancellable.le_tsub_of_add_le_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.le_tsub_of_add_le_left AddLECancellable.le_tsub_of_add_le_leftₓ'. -/
 protected theorem le_tsub_of_add_le_left (ha : AddLECancellable a) (h : a + b ≤ c) : b ≤ c - a :=
   ha <| h.trans le_add_tsub
 #align add_le_cancellable.le_tsub_of_add_le_left AddLECancellable.le_tsub_of_add_le_left
 
-/- warning: add_le_cancellable.le_tsub_of_add_le_right -> AddLECancellable.le_tsub_of_add_le_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b))
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.le_tsub_of_add_le_right AddLECancellable.le_tsub_of_add_le_rightₓ'. -/
 protected theorem le_tsub_of_add_le_right (hb : AddLECancellable b) (h : a + b ≤ c) : a ≤ c - b :=
   hb.le_tsub_of_add_le_left <| by rwa [add_comm]
 #align add_le_cancellable.le_tsub_of_add_le_right AddLECancellable.le_tsub_of_add_le_right
@@ -382,42 +226,18 @@ section Contra
 
 variable [ContravariantClass α α (· + ·) (· ≤ ·)]
 
-/- warning: le_add_tsub_swap -> le_add_tsub_swap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b a) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2214 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2216 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2214 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2216) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2229 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2231 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2229 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2231)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b a) b)
-Case conversion may be inaccurate. Consider using '#align le_add_tsub_swap le_add_tsub_swapₓ'. -/
 theorem le_add_tsub_swap : a ≤ b + a - b :=
   Contravariant.AddLECancellable.le_add_tsub_swap
 #align le_add_tsub_swap le_add_tsub_swap
 
-/- warning: le_add_tsub' -> le_add_tsub' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2278 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2280 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2278 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2280) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2293 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2295 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2293 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2295)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b)
-Case conversion may be inaccurate. Consider using '#align le_add_tsub' le_add_tsub'ₓ'. -/
 theorem le_add_tsub' : a ≤ a + b - b :=
   Contravariant.AddLECancellable.le_add_tsub
 #align le_add_tsub' le_add_tsub'
 
-/- warning: le_tsub_of_add_le_left -> le_tsub_of_add_le_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2342 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2344 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2342 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2344) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2357 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2359 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2357 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2359)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
-Case conversion may be inaccurate. Consider using '#align le_tsub_of_add_le_left le_tsub_of_add_le_leftₓ'. -/
 theorem le_tsub_of_add_le_left (h : a + b ≤ c) : b ≤ c - a :=
   Contravariant.AddLECancellable.le_tsub_of_add_le_left h
 #align le_tsub_of_add_le_left le_tsub_of_add_le_left
 
-/- warning: le_tsub_of_add_le_right -> le_tsub_of_add_le_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2412 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2414 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2412 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2414) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2427 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2429 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2427 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2429)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b))
-Case conversion may be inaccurate. Consider using '#align le_tsub_of_add_le_right le_tsub_of_add_le_rightₓ'. -/
 theorem le_tsub_of_add_le_right (h : a + b ≤ c) : a ≤ c - b :=
   Contravariant.AddLECancellable.le_tsub_of_add_le_right h
 #align le_tsub_of_add_le_right le_tsub_of_add_le_right
@@ -428,21 +248,9 @@ end AddCommSemigroup
 
 variable [AddCommMonoid α] [Sub α] [OrderedSub α] {a b c d : α}
 
-/- warning: tsub_nonpos -> tsub_nonpos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align tsub_nonpos tsub_nonposₓ'. -/
 theorem tsub_nonpos : a - b ≤ 0 ↔ a ≤ b := by rw [tsub_le_iff_left, add_zero]
 #align tsub_nonpos tsub_nonpos
 
-/- warning: tsub_nonpos_of_le -> tsub_nonpos_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)))))
-Case conversion may be inaccurate. Consider using '#align tsub_nonpos_of_le tsub_nonpos_of_leₓ'. -/
 alias tsub_nonpos ↔ _ tsub_nonpos_of_le
 #align tsub_nonpos_of_le tsub_nonpos_of_le
 
@@ -453,12 +261,6 @@ end Preorder
 
 variable [PartialOrder α] [AddCommSemigroup α] [Sub α] [OrderedSub α] {a b c d : α}
 
-/- warning: tsub_tsub -> tsub_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (b : α) (a : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a) c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (b : α) (a : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a) c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c))
-Case conversion may be inaccurate. Consider using '#align tsub_tsub tsub_tsubₓ'. -/
 theorem tsub_tsub (b a c : α) : b - a - c = b - (a + c) :=
   by
   apply le_antisymm
@@ -466,32 +268,14 @@ theorem tsub_tsub (b a c : α) : b - a - c = b - (a + c) :=
   · rw [tsub_le_iff_left, add_assoc, ← tsub_le_iff_left, ← tsub_le_iff_left]
 #align tsub_tsub tsub_tsub
 
-/- warning: tsub_add_eq_tsub_tsub -> tsub_add_eq_tsub_tsub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-Case conversion may be inaccurate. Consider using '#align tsub_add_eq_tsub_tsub tsub_add_eq_tsub_tsubₓ'. -/
 theorem tsub_add_eq_tsub_tsub (a b c : α) : a - (b + c) = a - b - c :=
   (tsub_tsub _ _ _).symm
 #align tsub_add_eq_tsub_tsub tsub_add_eq_tsub_tsub
 
-/- warning: tsub_add_eq_tsub_tsub_swap -> tsub_add_eq_tsub_tsub_swap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
-Case conversion may be inaccurate. Consider using '#align tsub_add_eq_tsub_tsub_swap tsub_add_eq_tsub_tsub_swapₓ'. -/
 theorem tsub_add_eq_tsub_tsub_swap (a b c : α) : a - (b + c) = a - c - b := by rw [add_comm];
   apply tsub_add_eq_tsub_tsub
 #align tsub_add_eq_tsub_tsub_swap tsub_add_eq_tsub_tsub_swap
 
-/- warning: tsub_right_comm -> tsub_right_comm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
-Case conversion may be inaccurate. Consider using '#align tsub_right_comm tsub_right_commₓ'. -/
 theorem tsub_right_comm : a - b - c = a - c - b := by simp_rw [← tsub_add_eq_tsub_tsub, add_comm]
 #align tsub_right_comm tsub_right_comm
 
@@ -500,64 +284,28 @@ theorem tsub_right_comm : a - b - c = a - c - b := by simp_rw [← tsub_add_eq_t
 
 namespace AddLECancellable
 
-/- warning: add_le_cancellable.tsub_eq_of_eq_add -> AddLECancellable.tsub_eq_of_eq_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.tsub_eq_of_eq_add AddLECancellable.tsub_eq_of_eq_addₓ'. -/
 protected theorem tsub_eq_of_eq_add (hb : AddLECancellable b) (h : a = c + b) : a - b = c :=
   le_antisymm (tsub_le_iff_right.mpr h.le) <| by rw [h]; exact hb.le_add_tsub
 #align add_le_cancellable.tsub_eq_of_eq_add AddLECancellable.tsub_eq_of_eq_add
 
-/- warning: add_le_cancellable.eq_tsub_of_add_eq -> AddLECancellable.eq_tsub_of_add_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (Eq.{succ u1} α a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (Eq.{succ u1} α a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.eq_tsub_of_add_eq AddLECancellable.eq_tsub_of_add_eqₓ'. -/
 protected theorem eq_tsub_of_add_eq (hc : AddLECancellable c) (h : a + c = b) : a = b - c :=
   (hc.tsub_eq_of_eq_add h.symm).symm
 #align add_le_cancellable.eq_tsub_of_add_eq AddLECancellable.eq_tsub_of_add_eq
 
-/- warning: add_le_cancellable.tsub_eq_of_eq_add_rev -> AddLECancellable.tsub_eq_of_eq_add_rev is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.tsub_eq_of_eq_add_rev AddLECancellable.tsub_eq_of_eq_add_revₓ'. -/
 protected theorem tsub_eq_of_eq_add_rev (hb : AddLECancellable b) (h : a = b + c) : a - b = c :=
   hb.tsub_eq_of_eq_add <| by rw [add_comm, h]
 #align add_le_cancellable.tsub_eq_of_eq_add_rev AddLECancellable.tsub_eq_of_eq_add_rev
 
-/- warning: add_le_cancellable.add_tsub_cancel_right -> AddLECancellable.add_tsub_cancel_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b) a)
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.add_tsub_cancel_right AddLECancellable.add_tsub_cancel_rightₓ'. -/
 @[simp]
 protected theorem add_tsub_cancel_right (hb : AddLECancellable b) : a + b - b = a :=
   hb.tsub_eq_of_eq_add <| by rw [add_comm]
 #align add_le_cancellable.add_tsub_cancel_right AddLECancellable.add_tsub_cancel_right
 
-/- warning: add_le_cancellable.add_tsub_cancel_left -> AddLECancellable.add_tsub_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b)
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.add_tsub_cancel_left AddLECancellable.add_tsub_cancel_leftₓ'. -/
 @[simp]
 protected theorem add_tsub_cancel_left (ha : AddLECancellable a) : a + b - a = b :=
   ha.tsub_eq_of_eq_add <| add_comm a b
 #align add_le_cancellable.add_tsub_cancel_left AddLECancellable.add_tsub_cancel_left
 
-/- warning: add_le_cancellable.lt_add_of_tsub_lt_left -> AddLECancellable.lt_add_of_tsub_lt_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.lt_add_of_tsub_lt_left AddLECancellable.lt_add_of_tsub_lt_leftₓ'. -/
 protected theorem lt_add_of_tsub_lt_left (hb : AddLECancellable b) (h : a - b < c) : a < b + c :=
   by
   rw [lt_iff_le_and_ne, ← tsub_le_iff_left]
@@ -566,12 +314,6 @@ protected theorem lt_add_of_tsub_lt_left (hb : AddLECancellable b) (h : a - b <
   simpa [hb] using h
 #align add_le_cancellable.lt_add_of_tsub_lt_left AddLECancellable.lt_add_of_tsub_lt_left
 
-/- warning: add_le_cancellable.lt_add_of_tsub_lt_right -> AddLECancellable.lt_add_of_tsub_lt_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.lt_add_of_tsub_lt_right AddLECancellable.lt_add_of_tsub_lt_rightₓ'. -/
 protected theorem lt_add_of_tsub_lt_right (hc : AddLECancellable c) (h : a - c < b) : a < b + c :=
   by
   rw [lt_iff_le_and_ne, ← tsub_le_iff_right]
@@ -580,22 +322,10 @@ protected theorem lt_add_of_tsub_lt_right (hc : AddLECancellable c) (h : a - c <
   simpa [hc] using h
 #align add_le_cancellable.lt_add_of_tsub_lt_right AddLECancellable.lt_add_of_tsub_lt_right
 
-/- warning: add_le_cancellable.lt_tsub_of_add_lt_right -> AddLECancellable.lt_tsub_of_add_lt_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.lt_tsub_of_add_lt_right AddLECancellable.lt_tsub_of_add_lt_rightₓ'. -/
 protected theorem lt_tsub_of_add_lt_right (hc : AddLECancellable c) (h : a + c < b) : a < b - c :=
   (hc.le_tsub_of_add_le_right h.le).lt_of_ne <| by rintro rfl; exact h.not_le le_tsub_add
 #align add_le_cancellable.lt_tsub_of_add_lt_right AddLECancellable.lt_tsub_of_add_lt_right
 
-/- warning: add_le_cancellable.lt_tsub_of_add_lt_left -> AddLECancellable.lt_tsub_of_add_lt_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
-Case conversion may be inaccurate. Consider using '#align add_le_cancellable.lt_tsub_of_add_lt_left AddLECancellable.lt_tsub_of_add_lt_leftₓ'. -/
 protected theorem lt_tsub_of_add_lt_left (ha : AddLECancellable a) (h : a + c < b) : c < b - a :=
   ha.lt_tsub_of_add_lt_right <| by rwa [add_comm]
 #align add_le_cancellable.lt_tsub_of_add_lt_left AddLECancellable.lt_tsub_of_add_lt_left
@@ -609,96 +339,42 @@ section Contra
 
 variable [ContravariantClass α α (· + ·) (· ≤ ·)]
 
-/- warning: tsub_eq_of_eq_add -> tsub_eq_of_eq_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3509 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3511 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3509 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3511) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3524 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3526 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3524 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3526)], (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-Case conversion may be inaccurate. Consider using '#align tsub_eq_of_eq_add tsub_eq_of_eq_addₓ'. -/
 theorem tsub_eq_of_eq_add (h : a = c + b) : a - b = c :=
   Contravariant.AddLECancellable.tsub_eq_of_eq_add h
 #align tsub_eq_of_eq_add tsub_eq_of_eq_add
 
-/- warning: eq_tsub_of_add_eq -> eq_tsub_of_add_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (Eq.{succ u1} α a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3579 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3581 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3579 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3581) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3594 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3596 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3594 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3596)], (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (Eq.{succ u1} α a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align eq_tsub_of_add_eq eq_tsub_of_add_eqₓ'. -/
 theorem eq_tsub_of_add_eq (h : a + c = b) : a = b - c :=
   Contravariant.AddLECancellable.eq_tsub_of_add_eq h
 #align eq_tsub_of_add_eq eq_tsub_of_add_eq
 
-/- warning: tsub_eq_of_eq_add_rev -> tsub_eq_of_eq_add_rev is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3649 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3651 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3649 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3651) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3664 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3666 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3664 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3666)], (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
-Case conversion may be inaccurate. Consider using '#align tsub_eq_of_eq_add_rev tsub_eq_of_eq_add_revₓ'. -/
 theorem tsub_eq_of_eq_add_rev (h : a = b + c) : a - b = c :=
   Contravariant.AddLECancellable.tsub_eq_of_eq_add_rev h
 #align tsub_eq_of_eq_add_rev tsub_eq_of_eq_add_rev
 
-/- warning: add_tsub_cancel_right -> add_tsub_cancel_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3719 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3721 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3719 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3721) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3734 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3736 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3734 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3736)] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b) a
-Case conversion may be inaccurate. Consider using '#align add_tsub_cancel_right add_tsub_cancel_rightₓ'. -/
 @[simp]
 theorem add_tsub_cancel_right (a b : α) : a + b - b = a :=
   Contravariant.AddLECancellable.add_tsub_cancel_right
 #align add_tsub_cancel_right add_tsub_cancel_right
 
-/- warning: add_tsub_cancel_left -> add_tsub_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3785 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3787 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3785 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3787) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3800 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3802 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3800 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3802)] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b
-Case conversion may be inaccurate. Consider using '#align add_tsub_cancel_left add_tsub_cancel_leftₓ'. -/
 @[simp]
 theorem add_tsub_cancel_left (a b : α) : a + b - a = b :=
   Contravariant.AddLECancellable.add_tsub_cancel_left
 #align add_tsub_cancel_left add_tsub_cancel_left
 
-/- warning: lt_add_of_tsub_lt_left -> lt_add_of_tsub_lt_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3851 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3853 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3851 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3853) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3866 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3868 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3866 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3868)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-Case conversion may be inaccurate. Consider using '#align lt_add_of_tsub_lt_left lt_add_of_tsub_lt_leftₓ'. -/
 theorem lt_add_of_tsub_lt_left (h : a - b < c) : a < b + c :=
   Contravariant.AddLECancellable.lt_add_of_tsub_lt_left h
 #align lt_add_of_tsub_lt_left lt_add_of_tsub_lt_left
 
-/- warning: lt_add_of_tsub_lt_right -> lt_add_of_tsub_lt_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3921 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3923 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3921 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3923) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3936 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3938 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3936 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3938)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
-Case conversion may be inaccurate. Consider using '#align lt_add_of_tsub_lt_right lt_add_of_tsub_lt_rightₓ'. -/
 theorem lt_add_of_tsub_lt_right (h : a - c < b) : a < b + c :=
   Contravariant.AddLECancellable.lt_add_of_tsub_lt_right h
 #align lt_add_of_tsub_lt_right lt_add_of_tsub_lt_right
 
-/- warning: lt_tsub_of_add_lt_left -> lt_tsub_of_add_lt_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3991 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3993 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3991 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3993) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4006 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4008 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4006 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4008)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
-Case conversion may be inaccurate. Consider using '#align lt_tsub_of_add_lt_left lt_tsub_of_add_lt_leftₓ'. -/
 /-- This lemma (and some of its corollaries) also holds for `ennreal`, but this proof doesn't work
 for it. Maybe we should add this lemma as field to `has_ordered_sub`? -/
 theorem lt_tsub_of_add_lt_left : a + c < b → c < b - a :=
   Contravariant.AddLECancellable.lt_tsub_of_add_lt_left
 #align lt_tsub_of_add_lt_left lt_tsub_of_add_lt_left
 
-/- warning: lt_tsub_of_add_lt_right -> lt_tsub_of_add_lt_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4061 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4063 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4061 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4063) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4076 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4078 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4076 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4078)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align lt_tsub_of_add_lt_right lt_tsub_of_add_lt_rightₓ'. -/
 theorem lt_tsub_of_add_lt_right : a + c < b → a < b - c :=
   Contravariant.AddLECancellable.lt_tsub_of_add_lt_right
 #align lt_tsub_of_add_lt_right lt_tsub_of_add_lt_right
@@ -709,12 +385,6 @@ section Both
 
 variable [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)]
 
-/- warning: add_tsub_add_eq_tsub_right -> add_tsub_add_eq_tsub_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] [_inst_6 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (c : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4222 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4224 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4222 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4224) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4237 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4239 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4237 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4239)] [_inst_6 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4256 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4258 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4256 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4258) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4271 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4273 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4271 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4273)] (a : α) (c : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
-Case conversion may be inaccurate. Consider using '#align add_tsub_add_eq_tsub_right add_tsub_add_eq_tsub_rightₓ'. -/
 theorem add_tsub_add_eq_tsub_right (a c b : α) : a + c - (b + c) = a - b :=
   by
   refine' add_tsub_add_le_tsub_right.antisymm (tsub_le_iff_right.2 <| le_of_add_le_add_right _);
@@ -723,12 +393,6 @@ theorem add_tsub_add_eq_tsub_right (a c b : α) : a + c - (b + c) = a - b :=
   exact le_tsub_add
 #align add_tsub_add_eq_tsub_right add_tsub_add_eq_tsub_right
 
-/- warning: add_tsub_add_eq_tsub_left -> add_tsub_add_eq_tsub_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] [_inst_6 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4371 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4373 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4371 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4373) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4386 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4388 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4386 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4388)] [_inst_6 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4405 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4407 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4405 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4407) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4420 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4422 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4420 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4422)] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align add_tsub_add_eq_tsub_left add_tsub_add_eq_tsub_leftₓ'. -/
 theorem add_tsub_add_eq_tsub_left (a b c : α) : a + b - (a + c) = b - c := by
   rw [add_comm a b, add_comm a c, add_tsub_add_eq_tsub_right]
 #align add_tsub_add_eq_tsub_left add_tsub_add_eq_tsub_left
@@ -744,45 +408,21 @@ section LinearOrder
 
 variable {a b c d : α} [LinearOrder α] [AddCommSemigroup α] [Sub α] [OrderedSub α]
 
-/- warning: lt_of_tsub_lt_tsub_right -> lt_of_tsub_lt_tsub_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)
-Case conversion may be inaccurate. Consider using '#align lt_of_tsub_lt_tsub_right lt_of_tsub_lt_tsub_rightₓ'. -/
 /-- See `lt_of_tsub_lt_tsub_right_of_le` for a weaker statement in a partial order. -/
 theorem lt_of_tsub_lt_tsub_right (h : a - c < b - c) : a < b :=
   lt_imp_lt_of_le_imp_le (fun h => tsub_le_tsub_right h c) h
 #align lt_of_tsub_lt_tsub_right lt_of_tsub_lt_tsub_right
 
-/- warning: lt_tsub_iff_right -> lt_tsub_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b)
-Case conversion may be inaccurate. Consider using '#align lt_tsub_iff_right lt_tsub_iff_rightₓ'. -/
 /-- See `lt_tsub_iff_right_of_le` for a weaker statement in a partial order. -/
 theorem lt_tsub_iff_right : a < b - c ↔ a + c < b :=
   lt_iff_lt_of_le_iff_le tsub_le_iff_right
 #align lt_tsub_iff_right lt_tsub_iff_right
 
-/- warning: lt_tsub_iff_left -> lt_tsub_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c a) b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c a) b)
-Case conversion may be inaccurate. Consider using '#align lt_tsub_iff_left lt_tsub_iff_leftₓ'. -/
 /-- See `lt_tsub_iff_left_of_le` for a weaker statement in a partial order. -/
 theorem lt_tsub_iff_left : a < b - c ↔ c + a < b :=
   lt_iff_lt_of_le_iff_le tsub_le_iff_left
 #align lt_tsub_iff_left lt_tsub_iff_left
 
-/- warning: lt_tsub_comm -> lt_tsub_comm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
-Case conversion may be inaccurate. Consider using '#align lt_tsub_comm lt_tsub_commₓ'. -/
 theorem lt_tsub_comm : a < b - c ↔ c < b - a :=
   lt_tsub_iff_left.trans lt_tsub_iff_right.symm
 #align lt_tsub_comm lt_tsub_comm
@@ -791,12 +431,6 @@ section Cov
 
 variable [CovariantClass α α (· + ·) (· ≤ ·)]
 
-/- warning: lt_of_tsub_lt_tsub_left -> lt_of_tsub_lt_tsub_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4757 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4759 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4757 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4759) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4772 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4774 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4772 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4774)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c b)
-Case conversion may be inaccurate. Consider using '#align lt_of_tsub_lt_tsub_left lt_of_tsub_lt_tsub_leftₓ'. -/
 /-- See `lt_of_tsub_lt_tsub_left_of_le` for a weaker statement in a partial order. -/
 theorem lt_of_tsub_lt_tsub_left (h : a - b < a - c) : c < b :=
   lt_imp_lt_of_le_imp_le (fun h => tsub_le_tsub_left h a) h
@@ -810,12 +444,6 @@ section OrderedAddCommMonoid
 
 variable [PartialOrder α] [AddCommMonoid α] [Sub α] [OrderedSub α]
 
-/- warning: tsub_zero -> tsub_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] (a : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))))))) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] (a : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))))) a
-Case conversion may be inaccurate. Consider using '#align tsub_zero tsub_zeroₓ'. -/
 @[simp]
 theorem tsub_zero (a : α) : a - 0 = a :=
   AddLECancellable.tsub_eq_of_eq_add addLECancellable_zero (add_zero _).symm

de29c328

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -215,9 +215,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.799 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.801 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.799 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.801) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.814 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.816 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.814 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.816)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align add_tsub_le_assoc add_tsub_le_assocₓ'. -/
 /-- See `add_tsub_assoc_of_le` for the equality. -/
-theorem add_tsub_le_assoc : a + b - c ≤ a + (b - c) :=
-  by
-  rw [tsub_le_iff_left, add_left_comm]
+theorem add_tsub_le_assoc : a + b - c ≤ a + (b - c) := by rw [tsub_le_iff_left, add_left_comm];
   exact add_le_add_left le_add_tsub a
 #align add_tsub_le_assoc add_tsub_le_assoc
 
@@ -228,9 +226,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.903 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.905 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.903 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.905) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.918 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.920 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.918 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.920)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
 Case conversion may be inaccurate. Consider using '#align add_tsub_le_tsub_add add_tsub_le_tsub_addₓ'. -/
 /-- See `tsub_add_eq_add_tsub` for the equality. -/
-theorem add_tsub_le_tsub_add : a + b - c ≤ a - c + b :=
-  by
-  rw [add_comm, add_comm _ b]
+theorem add_tsub_le_tsub_add : a + b - c ≤ a - c + b := by rw [add_comm, add_comm _ b];
   exact add_tsub_le_assoc
 #align add_tsub_le_tsub_add add_tsub_le_tsub_add
 
@@ -240,9 +236,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1007 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1009 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1007 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1009) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1022 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1024 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1022 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1024)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align add_le_add_add_tsub add_le_add_add_tsubₓ'. -/
-theorem add_le_add_add_tsub : a + b ≤ a + c + (b - c) :=
-  by
-  rw [add_assoc]
+theorem add_le_add_add_tsub : a + b ≤ a + c + (b - c) := by rw [add_assoc];
   exact add_le_add_left le_add_tsub a
 #align add_le_add_add_tsub add_le_add_add_tsub
 
@@ -252,9 +246,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1110 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1112 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1110 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1112) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1125 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1127 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1125 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1127)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 Case conversion may be inaccurate. Consider using '#align le_tsub_add_add le_tsub_add_addₓ'. -/
-theorem le_tsub_add_add : a + b ≤ a - c + (b + c) :=
-  by
-  rw [add_comm a, add_comm (a - c)]
+theorem le_tsub_add_add : a + b ≤ a - c + (b + c) := by rw [add_comm a, add_comm (a - c)];
   exact add_le_add_add_tsub
 #align le_tsub_add_add le_tsub_add_add
 
@@ -319,9 +311,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1731 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1733 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1731 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1733) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1746 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1748 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1746 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1748)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
 Case conversion may be inaccurate. Consider using '#align add_tsub_add_le_tsub_left add_tsub_add_le_tsub_leftₓ'. -/
 /-- See `add_tsub_add_eq_tsub_left` for the equality. -/
-theorem add_tsub_add_le_tsub_left : a + b - (a + c) ≤ b - c :=
-  by
-  rw [tsub_le_iff_left, add_assoc]
+theorem add_tsub_add_le_tsub_left : a + b - (a + c) ≤ b - c := by rw [tsub_le_iff_left, add_assoc];
   exact add_le_add_left le_add_tsub _
 #align add_tsub_add_le_tsub_left add_tsub_add_le_tsub_left
 
@@ -332,10 +322,8 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1835 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1837 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1835 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1837) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1850 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1852 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1850 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1852)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
 Case conversion may be inaccurate. Consider using '#align add_tsub_add_le_tsub_right add_tsub_add_le_tsub_rightₓ'. -/
 /-- See `add_tsub_add_eq_tsub_right` for the equality. -/
-theorem add_tsub_add_le_tsub_right : a + c - (b + c) ≤ a - b :=
-  by
-  rw [tsub_le_iff_left, add_right_comm]
-  exact add_le_add_right le_add_tsub c
+theorem add_tsub_add_le_tsub_right : a + c - (b + c) ≤ a - b := by
+  rw [tsub_le_iff_left, add_right_comm]; exact add_le_add_right le_add_tsub c
 #align add_tsub_add_le_tsub_right add_tsub_add_le_tsub_right
 
 end Cov
@@ -361,9 +349,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.le_add_tsub AddLECancellable.le_add_tsubₓ'. -/
-protected theorem le_add_tsub (hb : AddLECancellable b) : a ≤ a + b - b :=
-  by
-  rw [add_comm]
+protected theorem le_add_tsub (hb : AddLECancellable b) : a ≤ a + b - b := by rw [add_comm];
   exact hb.le_add_tsub_swap
 #align add_le_cancellable.le_add_tsub AddLECancellable.le_add_tsub
 
@@ -496,9 +482,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
 Case conversion may be inaccurate. Consider using '#align tsub_add_eq_tsub_tsub_swap tsub_add_eq_tsub_tsub_swapₓ'. -/
-theorem tsub_add_eq_tsub_tsub_swap (a b c : α) : a - (b + c) = a - c - b :=
-  by
-  rw [add_comm]
+theorem tsub_add_eq_tsub_tsub_swap (a b c : α) : a - (b + c) = a - c - b := by rw [add_comm];
   apply tsub_add_eq_tsub_tsub
 #align tsub_add_eq_tsub_tsub_swap tsub_add_eq_tsub_tsub_swap
 
@@ -523,9 +507,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.tsub_eq_of_eq_add AddLECancellable.tsub_eq_of_eq_addₓ'. -/
 protected theorem tsub_eq_of_eq_add (hb : AddLECancellable b) (h : a = c + b) : a - b = c :=
-  le_antisymm (tsub_le_iff_right.mpr h.le) <| by
-    rw [h]
-    exact hb.le_add_tsub
+  le_antisymm (tsub_le_iff_right.mpr h.le) <| by rw [h]; exact hb.le_add_tsub
 #align add_le_cancellable.tsub_eq_of_eq_add AddLECancellable.tsub_eq_of_eq_add
 
 /- warning: add_le_cancellable.eq_tsub_of_add_eq -> AddLECancellable.eq_tsub_of_add_eq is a dubious translation:
@@ -605,10 +587,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.lt_tsub_of_add_lt_right AddLECancellable.lt_tsub_of_add_lt_rightₓ'. -/
 protected theorem lt_tsub_of_add_lt_right (hc : AddLECancellable c) (h : a + c < b) : a < b - c :=
-  (hc.le_tsub_of_add_le_right h.le).lt_of_ne <|
-    by
-    rintro rfl
-    exact h.not_le le_tsub_add
+  (hc.le_tsub_of_add_le_right h.le).lt_of_ne <| by rintro rfl; exact h.not_le le_tsub_add
 #align add_le_cancellable.lt_tsub_of_add_lt_right AddLECancellable.lt_tsub_of_add_lt_right
 
 /- warning: add_le_cancellable.lt_tsub_of_add_lt_left -> AddLECancellable.lt_tsub_of_add_lt_left is a dubious translation:

de29c328

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -68,25 +68,37 @@ section Add
 
 variable [Preorder α] [Add α] [Sub α] [OrderedSub α] {a b c d : α}
 
-#print tsub_le_iff_right /-
+/- warning: tsub_le_iff_right -> tsub_le_iff_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) c b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) c b))
+Case conversion may be inaccurate. Consider using '#align tsub_le_iff_right tsub_le_iff_rightₓ'. -/
 @[simp]
 theorem tsub_le_iff_right : a - b ≤ c ↔ a ≤ c + b :=
   OrderedSub.tsub_le_iff_right a b c
 #align tsub_le_iff_right tsub_le_iff_right
--/
 
-#print add_tsub_le_right /-
+/- warning: add_tsub_le_right -> add_tsub_le_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) a b) b) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) a b) b) a
+Case conversion may be inaccurate. Consider using '#align add_tsub_le_right add_tsub_le_rightₓ'. -/
 /-- See `add_tsub_cancel_right` for the equality if `contravariant_class α α (+) (≤)`. -/
 theorem add_tsub_le_right : a + b - b ≤ a :=
   tsub_le_iff_right.mpr le_rfl
 #align add_tsub_le_right add_tsub_le_right
--/
 
-#print le_tsub_add /-
+/- warning: le_tsub_add -> le_tsub_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2 _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_2) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a) a)
+Case conversion may be inaccurate. Consider using '#align le_tsub_add le_tsub_addₓ'. -/
 theorem le_tsub_add : b ≤ b - a + a :=
   tsub_le_iff_right.mp le_rfl
 #align le_tsub_add le_tsub_add
--/
 
 end Add
 
@@ -105,7 +117,7 @@ variable [AddCommSemigroup α] [Sub α] [OrderedSub α] {a b c d : α}
 
 /- warning: tsub_le_iff_left -> tsub_le_iff_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 Case conversion may be inaccurate. Consider using '#align tsub_le_iff_left tsub_le_iff_leftₓ'. -/
@@ -114,7 +126,7 @@ theorem tsub_le_iff_left : a - b ≤ c ↔ a ≤ b + c := by rw [tsub_le_iff_rig
 
 /- warning: le_add_tsub -> le_add_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b))
 Case conversion may be inaccurate. Consider using '#align le_add_tsub le_add_tsubₓ'. -/
@@ -124,7 +136,7 @@ theorem le_add_tsub : a ≤ b + (a - b) :=
 
 /- warning: add_tsub_le_left -> add_tsub_le_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b
 Case conversion may be inaccurate. Consider using '#align add_tsub_le_left add_tsub_le_leftₓ'. -/
@@ -135,7 +147,7 @@ theorem add_tsub_le_left : a + b - a ≤ b :=
 
 /- warning: tsub_le_tsub_right -> tsub_le_tsub_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (forall (c : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (forall (c : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (forall (c : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align tsub_le_tsub_right tsub_le_tsub_rightₓ'. -/
@@ -145,7 +157,7 @@ theorem tsub_le_tsub_right (h : a ≤ b) (c : α) : a - c ≤ b - c :=
 
 /- warning: tsub_le_iff_tsub_le -> tsub_le_iff_tsub_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
 Case conversion may be inaccurate. Consider using '#align tsub_le_iff_tsub_le tsub_le_iff_tsub_leₓ'. -/
@@ -154,7 +166,7 @@ theorem tsub_le_iff_tsub_le : a - b ≤ c ↔ a - c ≤ b := by rw [tsub_le_iff_
 
 /- warning: tsub_tsub_le -> tsub_tsub_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a)) a
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a)) a
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a)) a
 Case conversion may be inaccurate. Consider using '#align tsub_tsub_le tsub_tsub_leₓ'. -/
@@ -169,7 +181,7 @@ variable [CovariantClass α α (· + ·) (· ≤ ·)]
 
 /- warning: tsub_le_tsub_left -> tsub_le_tsub_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (forall (c : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (forall (c : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.564 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.566 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.564 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.566) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.579 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.581 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.579 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.581)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (forall (c : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
 Case conversion may be inaccurate. Consider using '#align tsub_le_tsub_left tsub_le_tsub_leftₓ'. -/
@@ -179,7 +191,7 @@ theorem tsub_le_tsub_left (h : a ≤ b) (c : α) : c - b ≤ c - a :=
 
 /- warning: tsub_le_tsub -> tsub_le_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} {d : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a d) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} {d : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a d) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} {d : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.642 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.644 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.642 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.644) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.657 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.659 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.657 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.659)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a d) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align tsub_le_tsub tsub_le_tsubₓ'. -/
@@ -189,7 +201,7 @@ theorem tsub_le_tsub (hab : a ≤ b) (hcd : c ≤ d) : a - d ≤ b - c :=
 
 /- warning: antitone_const_tsub -> antitone_const_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], Antitone.{u1, u1} α α _inst_1 _inst_1 (fun (x : α) => HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c x)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], Antitone.{u1, u1} α α _inst_1 _inst_1 (fun (x : α) => HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c x)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.726 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.728 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.726 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.728) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.741 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.743 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.741 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.743)], Antitone.{u1, u1} α α _inst_1 _inst_1 (fun (x : α) => HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c x)
 Case conversion may be inaccurate. Consider using '#align antitone_const_tsub antitone_const_tsubₓ'. -/
@@ -198,7 +210,7 @@ theorem antitone_const_tsub : Antitone fun x => c - x := fun x y hxy => tsub_le_
 
 /- warning: add_tsub_le_assoc -> add_tsub_le_assoc is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.799 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.801 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.799 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.801) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.814 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.816 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.814 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.816)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align add_tsub_le_assoc add_tsub_le_assocₓ'. -/
@@ -211,7 +223,7 @@ theorem add_tsub_le_assoc : a + b - c ≤ a + (b - c) :=
 
 /- warning: add_tsub_le_tsub_add -> add_tsub_le_tsub_add is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.903 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.905 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.903 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.905) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.918 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.920 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.918 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.920)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
 Case conversion may be inaccurate. Consider using '#align add_tsub_le_tsub_add add_tsub_le_tsub_addₓ'. -/
@@ -224,7 +236,7 @@ theorem add_tsub_le_tsub_add : a + b - c ≤ a - c + b :=
 
 /- warning: add_le_add_add_tsub -> add_le_add_add_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1007 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1009 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1007 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1009) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1022 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1024 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1022 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1024)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align add_le_add_add_tsub add_le_add_add_tsubₓ'. -/
@@ -236,7 +248,7 @@ theorem add_le_add_add_tsub : a + b ≤ a + c + (b - c) :=
 
 /- warning: le_tsub_add_add -> le_tsub_add_add is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1110 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1112 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1110 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1112) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1125 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1127 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1125 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1127)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 Case conversion may be inaccurate. Consider using '#align le_tsub_add_add le_tsub_add_addₓ'. -/
@@ -248,7 +260,7 @@ theorem le_tsub_add_add : a + b ≤ a - c + (b + c) :=
 
 /- warning: tsub_le_tsub_add_tsub -> tsub_le_tsub_add_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1220 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1222 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1220 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1222) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1235 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1237 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1235 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1237)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align tsub_le_tsub_add_tsub tsub_le_tsub_add_tsubₓ'. -/
@@ -260,7 +272,7 @@ theorem tsub_le_tsub_add_tsub : a - c ≤ a - b + (b - c) :=
 
 /- warning: tsub_tsub_tsub_le_tsub -> tsub_tsub_tsub_le_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1328 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1330 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1328 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1330) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1343 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1345 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1343 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1345)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a)
 Case conversion may be inaccurate. Consider using '#align tsub_tsub_tsub_le_tsub tsub_tsub_tsub_le_tsubₓ'. -/
@@ -272,7 +284,7 @@ theorem tsub_tsub_tsub_le_tsub : c - a - (c - b) ≤ b - a :=
 
 /- warning: tsub_tsub_le_tsub_add -> tsub_tsub_le_tsub_add is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))] {a : α} {b : α} {c : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))] {a : α} {b : α} {c : α}, LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1436 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1438 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1436 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1438) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1451 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1453 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1451 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1453)] {a : α} {b : α} {c : α}, LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 Case conversion may be inaccurate. Consider using '#align tsub_tsub_le_tsub_add tsub_tsub_le_tsub_addₓ'. -/
@@ -287,7 +299,7 @@ theorem tsub_tsub_le_tsub_add {a b c : α} : a - (b - c) ≤ a - b + c :=
 
 /- warning: add_tsub_add_le_tsub_add_tsub -> add_tsub_add_le_tsub_add_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} {d : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c d)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b d))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} {d : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c d)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b d))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} {d : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1575 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1577 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1575 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1577) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1590 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1592 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1590 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1592)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c d)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b d))
 Case conversion may be inaccurate. Consider using '#align add_tsub_add_le_tsub_add_tsub add_tsub_add_le_tsub_add_tsubₓ'. -/
@@ -302,7 +314,7 @@ theorem add_tsub_add_le_tsub_add_tsub : a + b - (c + d) ≤ a - c + (b - d) :=
 
 /- warning: add_tsub_add_le_tsub_left -> add_tsub_add_le_tsub_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1731 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1733 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1731 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1733) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1746 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1748 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1746 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1748)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
 Case conversion may be inaccurate. Consider using '#align add_tsub_add_le_tsub_left add_tsub_add_le_tsub_leftₓ'. -/
@@ -315,7 +327,7 @@ theorem add_tsub_add_le_tsub_left : a + b - (a + c) ≤ b - c :=
 
 /- warning: add_tsub_add_le_tsub_right -> add_tsub_add_le_tsub_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1835 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1837 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1835 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1837) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1850 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1852 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1850 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.1852)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
 Case conversion may be inaccurate. Consider using '#align add_tsub_add_le_tsub_right add_tsub_add_le_tsub_rightₓ'. -/
@@ -335,7 +347,7 @@ namespace AddLECancellable
 
 /- warning: add_le_cancellable.le_add_tsub_swap -> AddLECancellable.le_add_tsub_swap is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b a) b))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b a) b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b a) b))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.le_add_tsub_swap AddLECancellable.le_add_tsub_swapₓ'. -/
@@ -345,7 +357,7 @@ protected theorem le_add_tsub_swap (hb : AddLECancellable b) : a ≤ b + a - b :
 
 /- warning: add_le_cancellable.le_add_tsub -> AddLECancellable.le_add_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.le_add_tsub AddLECancellable.le_add_tsubₓ'. -/
@@ -357,7 +369,7 @@ protected theorem le_add_tsub (hb : AddLECancellable b) : a ≤ a + b - b :=
 
 /- warning: add_le_cancellable.le_tsub_of_add_le_left -> AddLECancellable.le_tsub_of_add_le_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.le_tsub_of_add_le_left AddLECancellable.le_tsub_of_add_le_leftₓ'. -/
@@ -367,7 +379,7 @@ protected theorem le_tsub_of_add_le_left (ha : AddLECancellable a) (h : a + b 
 
 /- warning: add_le_cancellable.le_tsub_of_add_le_right -> AddLECancellable.le_tsub_of_add_le_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α _inst_1) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.le_tsub_of_add_le_right AddLECancellable.le_tsub_of_add_le_rightₓ'. -/
@@ -386,7 +398,7 @@ variable [ContravariantClass α α (· + ·) (· ≤ ·)]
 
 /- warning: le_add_tsub_swap -> le_add_tsub_swap is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b a) b)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b a) b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2214 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2216 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2214 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2216) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2229 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2231 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2229 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2231)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b a) b)
 Case conversion may be inaccurate. Consider using '#align le_add_tsub_swap le_add_tsub_swapₓ'. -/
@@ -396,7 +408,7 @@ theorem le_add_tsub_swap : a ≤ b + a - b :=
 
 /- warning: le_add_tsub' -> le_add_tsub' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2278 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2280 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2278 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2280) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2293 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2295 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2293 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2295)], LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b)
 Case conversion may be inaccurate. Consider using '#align le_add_tsub' le_add_tsub'ₓ'. -/
@@ -406,7 +418,7 @@ theorem le_add_tsub' : a ≤ a + b - b :=
 
 /- warning: le_tsub_of_add_le_left -> le_tsub_of_add_le_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2342 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2344 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2342 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2344) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2357 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2359 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2357 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2359)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c a))
 Case conversion may be inaccurate. Consider using '#align le_tsub_of_add_le_left le_tsub_of_add_le_leftₓ'. -/
@@ -416,7 +428,7 @@ theorem le_tsub_of_add_le_left (h : a + b ≤ c) : b ≤ c - a :=
 
 /- warning: le_tsub_of_add_le_right -> le_tsub_of_add_le_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2412 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2414 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2412 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2414) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2427 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2429 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2427 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.2429)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) c b))
 Case conversion may be inaccurate. Consider using '#align le_tsub_of_add_le_right le_tsub_of_add_le_rightₓ'. -/
@@ -432,7 +444,7 @@ variable [AddCommMonoid α] [Sub α] [OrderedSub α] {a b c d : α}
 
 /- warning: tsub_nonpos -> tsub_nonpos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
 Case conversion may be inaccurate. Consider using '#align tsub_nonpos tsub_nonposₓ'. -/
@@ -441,7 +453,7 @@ theorem tsub_nonpos : a - b ≤ 0 ↔ a ≤ b := by rw [tsub_le_iff_left, add_ze
 
 /- warning: tsub_nonpos_of_le -> tsub_nonpos_of_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)))))))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)))))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α _inst_1) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align tsub_nonpos_of_le tsub_nonpos_of_leₓ'. -/
@@ -457,7 +469,7 @@ variable [PartialOrder α] [AddCommSemigroup α] [Sub α] [OrderedSub α] {a b c
 
 /- warning: tsub_tsub -> tsub_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (b : α) (a : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a) c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (b : α) (a : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a) c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (b : α) (a : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a) c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c))
 Case conversion may be inaccurate. Consider using '#align tsub_tsub tsub_tsubₓ'. -/
@@ -470,7 +482,7 @@ theorem tsub_tsub (b a c : α) : b - a - c = b - (a + c) :=
 
 /- warning: tsub_add_eq_tsub_tsub -> tsub_add_eq_tsub_tsub is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 Case conversion may be inaccurate. Consider using '#align tsub_add_eq_tsub_tsub tsub_add_eq_tsub_tsubₓ'. -/
@@ -480,7 +492,7 @@ theorem tsub_add_eq_tsub_tsub (a b c : α) : a - (b + c) = a - b - c :=
 
 /- warning: tsub_add_eq_tsub_tsub_swap -> tsub_add_eq_tsub_tsub_swap is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
 Case conversion may be inaccurate. Consider using '#align tsub_add_eq_tsub_tsub_swap tsub_add_eq_tsub_tsub_swapₓ'. -/
@@ -492,7 +504,7 @@ theorem tsub_add_eq_tsub_tsub_swap (a b c : α) : a - (b + c) = a - c - b :=
 
 /- warning: tsub_right_comm -> tsub_right_comm is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b)
 Case conversion may be inaccurate. Consider using '#align tsub_right_comm tsub_right_commₓ'. -/
@@ -506,7 +518,7 @@ namespace AddLECancellable
 
 /- warning: add_le_cancellable.tsub_eq_of_eq_add -> AddLECancellable.tsub_eq_of_eq_add is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.tsub_eq_of_eq_add AddLECancellable.tsub_eq_of_eq_addₓ'. -/
@@ -518,7 +530,7 @@ protected theorem tsub_eq_of_eq_add (hb : AddLECancellable b) (h : a = c + b) :
 
 /- warning: add_le_cancellable.eq_tsub_of_add_eq -> AddLECancellable.eq_tsub_of_add_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (Eq.{succ u1} α a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (Eq.{succ u1} α a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (Eq.{succ u1} α a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.eq_tsub_of_add_eq AddLECancellable.eq_tsub_of_add_eqₓ'. -/
@@ -528,7 +540,7 @@ protected theorem eq_tsub_of_add_eq (hc : AddLECancellable c) (h : a + c = b) :
 
 /- warning: add_le_cancellable.tsub_eq_of_eq_add_rev -> AddLECancellable.tsub_eq_of_eq_add_rev is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.tsub_eq_of_eq_add_rev AddLECancellable.tsub_eq_of_eq_add_revₓ'. -/
@@ -538,7 +550,7 @@ protected theorem tsub_eq_of_eq_add_rev (hb : AddLECancellable b) (h : a = b + c
 
 /- warning: add_le_cancellable.add_tsub_cancel_right -> AddLECancellable.add_tsub_cancel_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b) a)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b) a)
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.add_tsub_cancel_right AddLECancellable.add_tsub_cancel_rightₓ'. -/
@@ -549,7 +561,7 @@ protected theorem add_tsub_cancel_right (hb : AddLECancellable b) : a + b - b =
 
 /- warning: add_le_cancellable.add_tsub_cancel_left -> AddLECancellable.add_tsub_cancel_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b)
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.add_tsub_cancel_left AddLECancellable.add_tsub_cancel_leftₓ'. -/
@@ -560,7 +572,7 @@ protected theorem add_tsub_cancel_left (ha : AddLECancellable a) : a + b - a = b
 
 /- warning: add_le_cancellable.lt_add_of_tsub_lt_left -> AddLECancellable.lt_add_of_tsub_lt_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.lt_add_of_tsub_lt_left AddLECancellable.lt_add_of_tsub_lt_leftₓ'. -/
@@ -574,7 +586,7 @@ protected theorem lt_add_of_tsub_lt_left (hb : AddLECancellable b) (h : a - b <
 
 /- warning: add_le_cancellable.lt_add_of_tsub_lt_right -> AddLECancellable.lt_add_of_tsub_lt_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.lt_add_of_tsub_lt_right AddLECancellable.lt_add_of_tsub_lt_rightₓ'. -/
@@ -588,7 +600,7 @@ protected theorem lt_add_of_tsub_lt_right (hc : AddLECancellable c) (h : a - c <
 
 /- warning: add_le_cancellable.lt_tsub_of_add_lt_right -> AddLECancellable.lt_tsub_of_add_lt_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.lt_tsub_of_add_lt_right AddLECancellable.lt_tsub_of_add_lt_rightₓ'. -/
@@ -601,7 +613,7 @@ protected theorem lt_tsub_of_add_lt_right (hc : AddLECancellable c) (h : a + c <
 
 /- warning: add_le_cancellable.lt_tsub_of_add_lt_left -> AddLECancellable.lt_tsub_of_add_lt_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α}, (AddLECancellable.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
 Case conversion may be inaccurate. Consider using '#align add_le_cancellable.lt_tsub_of_add_lt_left AddLECancellable.lt_tsub_of_add_lt_leftₓ'. -/
@@ -620,7 +632,7 @@ variable [ContravariantClass α α (· + ·) (· ≤ ·)]
 
 /- warning: tsub_eq_of_eq_add -> tsub_eq_of_eq_add is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3509 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3511 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3509 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3511) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3524 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3526 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3524 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3526)], (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c b)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 Case conversion may be inaccurate. Consider using '#align tsub_eq_of_eq_add tsub_eq_of_eq_addₓ'. -/
@@ -630,7 +642,7 @@ theorem tsub_eq_of_eq_add (h : a = c + b) : a - b = c :=
 
 /- warning: eq_tsub_of_add_eq -> eq_tsub_of_add_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (Eq.{succ u1} α a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (Eq.{succ u1} α a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3579 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3581 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3579 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3581) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3594 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3596 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3594 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3596)], (Eq.{succ u1} α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (Eq.{succ u1} α a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align eq_tsub_of_add_eq eq_tsub_of_add_eqₓ'. -/
@@ -640,7 +652,7 @@ theorem eq_tsub_of_add_eq (h : a + c = b) : a = b - c :=
 
 /- warning: tsub_eq_of_eq_add_rev -> tsub_eq_of_eq_add_rev is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3649 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3651 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3649 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3651) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3664 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3666 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3664 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3666)], (Eq.{succ u1} α a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) -> (Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c)
 Case conversion may be inaccurate. Consider using '#align tsub_eq_of_eq_add_rev tsub_eq_of_eq_add_revₓ'. -/
@@ -650,7 +662,7 @@ theorem tsub_eq_of_eq_add_rev (h : a = b + c) : a - b = c :=
 
 /- warning: add_tsub_cancel_right -> add_tsub_cancel_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b) a
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b) a
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3719 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3721 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3719 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3721) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3734 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3736 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3734 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3736)] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) b) a
 Case conversion may be inaccurate. Consider using '#align add_tsub_cancel_right add_tsub_cancel_rightₓ'. -/
@@ -661,7 +673,7 @@ theorem add_tsub_cancel_right (a b : α) : a + b - b = a :=
 
 /- warning: add_tsub_cancel_left -> add_tsub_cancel_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3785 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3787 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3785 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3787) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3800 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3802 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3800 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3802)] (a : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) a) b
 Case conversion may be inaccurate. Consider using '#align add_tsub_cancel_left add_tsub_cancel_leftₓ'. -/
@@ -672,7 +684,7 @@ theorem add_tsub_cancel_left (a b : α) : a + b - a = b :=
 
 /- warning: lt_add_of_tsub_lt_left -> lt_add_of_tsub_lt_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3851 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3853 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3851 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3853) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3866 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3868 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3866 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3868)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 Case conversion may be inaccurate. Consider using '#align lt_add_of_tsub_lt_left lt_add_of_tsub_lt_leftₓ'. -/
@@ -682,7 +694,7 @@ theorem lt_add_of_tsub_lt_left (h : a - b < c) : a < b + c :=
 
 /- warning: lt_add_of_tsub_lt_right -> lt_add_of_tsub_lt_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3921 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3923 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3921 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3923) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3936 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3938 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3936 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3938)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c))
 Case conversion may be inaccurate. Consider using '#align lt_add_of_tsub_lt_right lt_add_of_tsub_lt_rightₓ'. -/
@@ -692,7 +704,7 @@ theorem lt_add_of_tsub_lt_right (h : a - c < b) : a < b + c :=
 
 /- warning: lt_tsub_of_add_lt_left -> lt_tsub_of_add_lt_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3991 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3993 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3991 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.3993) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4006 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4008 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4006 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4008)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
 Case conversion may be inaccurate. Consider using '#align lt_tsub_of_add_lt_left lt_tsub_of_add_lt_leftₓ'. -/
@@ -704,7 +716,7 @@ theorem lt_tsub_of_add_lt_left : a + c < b → c < b - a :=
 
 /- warning: lt_tsub_of_add_lt_right -> lt_tsub_of_add_lt_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] {a : α} {b : α} {c : α} [_inst_5 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4061 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4063 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4061 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4063) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4076 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4078 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4076 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4078)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c))
 Case conversion may be inaccurate. Consider using '#align lt_tsub_of_add_lt_right lt_tsub_of_add_lt_rightₓ'. -/
@@ -720,7 +732,7 @@ variable [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α
 
 /- warning: add_tsub_add_eq_tsub_right -> add_tsub_add_eq_tsub_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] [_inst_6 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (c : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] [_inst_6 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (c : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4222 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4224 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4222 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4224) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4237 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4239 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4237 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4239)] [_inst_6 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4256 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4258 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4256 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4258) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4271 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4273 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4271 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4273)] (a : α) (c : α) (b : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) b c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b)
 Case conversion may be inaccurate. Consider using '#align add_tsub_add_eq_tsub_right add_tsub_add_eq_tsub_rightₓ'. -/
@@ -734,7 +746,7 @@ theorem add_tsub_add_eq_tsub_right (a c b : α) : a + c - (b + c) = a - b :=
 
 /- warning: add_tsub_add_eq_tsub_left -> add_tsub_add_eq_tsub_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] [_inst_6 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] [_inst_6 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)))] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4371 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4373 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4371 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4373) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4386 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4388 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4386 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4388)] [_inst_6 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4405 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4407 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4405 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4407) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4420 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4422 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4420 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4422)] (a : α) (b : α) (c : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a b) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)
 Case conversion may be inaccurate. Consider using '#align add_tsub_add_eq_tsub_left add_tsub_add_eq_tsub_leftₓ'. -/
@@ -755,7 +767,7 @@ variable {a b c d : α} [LinearOrder α] [AddCommSemigroup α] [Sub α] [Ordered
 
 /- warning: lt_of_tsub_lt_tsub_right -> lt_of_tsub_lt_tsub_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)
 Case conversion may be inaccurate. Consider using '#align lt_of_tsub_lt_tsub_right lt_of_tsub_lt_tsub_rightₓ'. -/
@@ -766,7 +778,7 @@ theorem lt_of_tsub_lt_tsub_right (h : a - c < b - c) : a < b :=
 
 /- warning: lt_tsub_iff_right -> lt_tsub_iff_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) a c) b)
 Case conversion may be inaccurate. Consider using '#align lt_tsub_iff_right lt_tsub_iff_rightₓ'. -/
@@ -777,7 +789,7 @@ theorem lt_tsub_iff_right : a < b - c ↔ a + c < b :=
 
 /- warning: lt_tsub_iff_left -> lt_tsub_iff_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c a) b)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c a) b)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) c a) b)
 Case conversion may be inaccurate. Consider using '#align lt_tsub_iff_left lt_tsub_iff_leftₓ'. -/
@@ -788,7 +800,7 @@ theorem lt_tsub_iff_left : a < b - c ↔ c + a < b :=
 
 /- warning: lt_tsub_comm -> lt_tsub_comm is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) b a))
 Case conversion may be inaccurate. Consider using '#align lt_tsub_comm lt_tsub_commₓ'. -/
@@ -802,7 +814,7 @@ variable [CovariantClass α α (· + ·) (· ≤ ·)]
 
 /- warning: lt_of_tsub_lt_tsub_left -> lt_of_tsub_lt_tsub_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c b)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toHasAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c b)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : AddCommSemigroup.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2)) _inst_3] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4757 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4759 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddSemigroup.toAdd.{u1} α (AddCommSemigroup.toAddSemigroup.{u1} α _inst_2))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4757 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4759) (fun (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4772 : α) (x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4774 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4772 x._@.Mathlib.Algebra.Order.Sub.Defs._hyg.4774)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a b) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a c)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c b)
 Case conversion may be inaccurate. Consider using '#align lt_of_tsub_lt_tsub_left lt_of_tsub_lt_tsub_leftₓ'. -/
@@ -821,7 +833,7 @@ variable [PartialOrder α] [AddCommMonoid α] [Sub α] [OrderedSub α]
 
 /- warning: tsub_zero -> tsub_zero is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] (a : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))))))) a
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] (a : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))))))) a
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : AddCommMonoid.{u1} α] [_inst_3 : Sub.{u1} α] [_inst_4 : OrderedSub.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))) _inst_3] (a : α), Eq.{succ u1} α (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α _inst_2))))) a
 Case conversion may be inaccurate. Consider using '#align tsub_zero tsub_zeroₓ'. -/

de29c328

bump to nightly-2023-04-16-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/4f4a1c875d0baa92ab5d92f3fb1bb258ad9f3e5b

63127953

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 
 ! This file was ported from Lean 3 source module algebra.order.sub.defs
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
+! leanprover-community/mathlib commit de29c328903507bb7aff506af9135f4bdaf1849c
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -52,21 +52,17 @@ TODO: generalize `nat.le_of_le_of_sub_le_sub_right`, `nat.sub_le_sub_right_iff`,
 
 variable {α β : Type _}
 
-/- warning: has_ordered_sub -> OrderedSub is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : LE.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α], Type
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : LE.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α], Prop
-Case conversion may be inaccurate. Consider using '#align has_ordered_sub OrderedSubₓ'. -/
+#print OrderedSub /-
 /-- `has_ordered_sub α` means that `α` has a subtraction characterized by `a - b ≤ c ↔ a ≤ c + b`.
 In other words, `a - b` is the least `c` such that `a ≤ b + c`.
 
 This is satisfied both by the subtraction in additive ordered groups and by truncated subtraction
 in canonically ordered monoids on many specific types.
 -/
-class OrderedSub (α : Type _) [LE α] [Add α] [Sub α] where
+class OrderedSub (α : Type _) [LE α] [Add α] [Sub α] : Prop where
   tsub_le_iff_right : ∀ a b c : α, a - b ≤ c ↔ a ≤ c + b
 #align has_ordered_sub OrderedSub
+-/
 
 section Add

448144f7

bump to nightly-2023-04-14-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/7ebf83ed9c262adbf983ef64d5e8c2ae94b625f4

60fdc414

Diff

@@ -52,7 +52,12 @@ TODO: generalize `nat.le_of_le_of_sub_le_sub_right`, `nat.sub_le_sub_right_iff`,
 
 variable {α β : Type _}
 
-#print OrderedSub /-
+/- warning: has_ordered_sub -> OrderedSub is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [_inst_1 : LE.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α], Type
+but is expected to have type
+  forall (α : Type.{u1}) [_inst_1 : LE.{u1} α] [_inst_2 : Add.{u1} α] [_inst_3 : Sub.{u1} α], Prop
+Case conversion may be inaccurate. Consider using '#align has_ordered_sub OrderedSubₓ'. -/
 /-- `has_ordered_sub α` means that `α` has a subtraction characterized by `a - b ≤ c ↔ a ≤ c + b`.
 In other words, `a - b` is the least `c` such that `a ≤ b + c`.
 
@@ -62,7 +67,6 @@ in canonically ordered monoids on many specific types.
 class OrderedSub (α : Type _) [LE α] [Add α] [Sub α] where
   tsub_le_iff_right : ∀ a b c : α, a - b ≤ c ↔ a ≤ c + b
 #align has_ordered_sub OrderedSub
--/
 
 section Add

448144f7

bump to nightly-2023-03-01-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

20cadee0

Diff

@@ -280,7 +280,7 @@ theorem tsub_tsub_le_tsub_add {a b c : α} : a - (b - c) ≤ a - b + c :=
   tsub_le_iff_right.2 <|
     calc
       a ≤ a - b + b := le_tsub_add
-      _ ≤ a - b + (c + (b - c)) := add_le_add_left le_add_tsub _
+      _ ≤ a - b + (c + (b - c)) := (add_le_add_left le_add_tsub _)
       _ = a - b + c + (b - c) := (add_assoc _ _ _).symm
       
 #align tsub_tsub_le_tsub_add tsub_tsub_le_tsub_add

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

de29c328

chore: adapt to multiple goal linter 1 (#12338)

A PR accompanying #12339.

Zulip discussion

45f93f3f

Diff

@@ -389,9 +389,9 @@ variable [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α
 
 theorem add_tsub_add_eq_tsub_right (a c b : α) : a + c - (b + c) = a - b := by
   refine' add_tsub_add_le_tsub_right.antisymm (tsub_le_iff_right.2 <| le_of_add_le_add_right _)
-  exact c
-  rw [add_assoc]
-  exact le_tsub_add
+  · exact c
+  · rw [add_assoc]
+    exact le_tsub_add
 #align add_tsub_add_eq_tsub_right add_tsub_add_eq_tsub_right
 
 theorem add_tsub_add_eq_tsub_left (a b c : α) : a + b - (a + c) = b - c := by

de29c328

chore(Algebra/Order/Group): change simp lemmas (#7867)

608404e3

Diff

@@ -59,13 +59,14 @@ class OrderedSub (α : Type*) [LE α] [Add α] [Sub α] : Prop where
 
 section Add
 
-variable [Preorder α] [Add α] [Sub α] [OrderedSub α] {a b c d : α}
-
 @[simp]
-theorem tsub_le_iff_right : a - b ≤ c ↔ a ≤ c + b :=
+theorem tsub_le_iff_right [LE α] [Add α] [Sub α] [OrderedSub α] {a b c : α} :
+    a - b ≤ c ↔ a ≤ c + b :=
   OrderedSub.tsub_le_iff_right a b c
 #align tsub_le_iff_right tsub_le_iff_right
 
+variable [Preorder α] [Add α] [Sub α] [OrderedSub α] {a b c d : α}
+
 /-- See `add_tsub_cancel_right` for the equality if `ContravariantClass α α (+) (≤)`. -/
 theorem add_tsub_le_right : a + b - b ≤ a :=
   tsub_le_iff_right.mpr le_rfl

de29c328

chore: space after ← (#8178)

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

5fb9beab

Diff

@@ -274,7 +274,7 @@ theorem tsub_add_eq_tsub_tsub_swap (a b c : α) : a - (b + c) = a - c - b := by
 #align tsub_add_eq_tsub_tsub_swap tsub_add_eq_tsub_tsub_swap
 
 theorem tsub_right_comm : a - b - c = a - c - b := by
-  rw [←tsub_add_eq_tsub_tsub, tsub_add_eq_tsub_tsub_swap]
+  rw [← tsub_add_eq_tsub_tsub, tsub_add_eq_tsub_tsub_swap]
 #align tsub_right_comm tsub_right_comm
 
 /-! ### Lemmas that assume that an element is `AddLECancellable`. -/

de29c328

chore: gcongr tagging (#7889)

Tag lemmas about tsub (truncated subtraction), nnreal and ennreal powers, and measures for gcongr.

5fcd5523

Diff

@@ -103,7 +103,7 @@ theorem add_tsub_le_left : a + b - a ≤ b :=
   tsub_le_iff_left.mpr le_rfl
 #align add_tsub_le_left add_tsub_le_left
 
-theorem tsub_le_tsub_right (h : a ≤ b) (c : α) : a - c ≤ b - c :=
+@[gcongr] theorem tsub_le_tsub_right (h : a ≤ b) (c : α) : a - c ≤ b - c :=
   tsub_le_iff_left.mpr <| h.trans le_add_tsub
 #align tsub_le_tsub_right tsub_le_tsub_right
 
@@ -119,11 +119,11 @@ section Cov
 
 variable [CovariantClass α α (· + ·) (· ≤ ·)]
 
-theorem tsub_le_tsub_left (h : a ≤ b) (c : α) : c - b ≤ c - a :=
+@[gcongr] theorem tsub_le_tsub_left (h : a ≤ b) (c : α) : c - b ≤ c - a :=
   tsub_le_iff_left.mpr <| le_add_tsub.trans <| add_le_add_right h _
 #align tsub_le_tsub_left tsub_le_tsub_left
 
-theorem tsub_le_tsub (hab : a ≤ b) (hcd : c ≤ d) : a - d ≤ b - c :=
+@[gcongr] theorem tsub_le_tsub (hab : a ≤ b) (hcd : c ≤ d) : a - d ≤ b - c :=
   (tsub_le_tsub_right hab _).trans <| tsub_le_tsub_left hcd _
 #align tsub_le_tsub tsub_le_tsub

de29c328

chore: rename CanonicallyOrderedAddMonoid to ..AddCommMonoid (#7503)

Renames:

CanonicallyOrderedMonoid -> CanonicallyOrderedCommMonoid

CanonicallyOrderedAddMonoid -> CanonicallyOrderedAddCommMonoid

CanonicallyLinearOrderedMonoid -> CanonicallyLinearOrderedCommMonoid

CanonicallyLinearOrderedAddMonoid -> CanonicallyLinearOrderedAddCommMonoid

f3bc24c3

Diff

@@ -22,9 +22,9 @@ subtraction on a canonically ordered monoid (`ℕ`, `Multiset`, `PartENat`, `ENN
 ## Implementation details
 
 `OrderedSub` is a mixin type-class, so that we can use the results in this file even in cases
-where we don't have a `CanonicallyOrderedAddMonoid` instance
+where we don't have a `CanonicallyOrderedAddCommMonoid` instance
 (even though that is our main focus). Conversely, this means we can use
-`CanonicallyOrderedAddMonoid` without necessarily having to define a subtraction.
+`CanonicallyOrderedAddCommMonoid` without necessarily having to define a subtraction.
 
 The results in this file are ordered by the type-class assumption needed to prove it.
 This means that similar results might not be close to each other. Furthermore, we don't prove

de29c328

chore(Co(ntra)variantClass): generalize and remove duplicates (#6677)

4 files have major changes:

Algebra/CovariantAndContravariant.lean

Add new theorem contravariant_le_iff_contravariant_lt_and_eq.
Add covariantClass_le_of_lt generalizing and replacing Mul.to_covariantClass_left/right in Algebra/Order/Monoid/Defs.lean
Replace CommSemigroup by IsSymmOp N N mu and replace CancelSemigroup by IsMulCancel, removing superfluous associativity assumption.
new theorems covariant_lt_of_covariant_le_of_contravariant_eq and contravariant_le_of_contravariant_eq_and_lt that could replace eight instances when appropriate refactoring is in place.
Golfs
Fix changed names in other files.

Algebra/Order/Monoid/Lemmas.lean

Generalize mul_eq_mul_iff_eq_and_eq and remove the less general Left/Right.mul_eq_mul_iff_eq_and_eq.
Move mul_le_mul_iff_of_ge.
Introduce the more general Left/Right versions of min_le_max_of_mul_le_mul.
Move min_lt_max_of_mul_lt_mul here from Algebra/GroupPower/Order.lean.
Replace CommSemigroup by IsSymmOp.

Algebra/Order/Monoid/Basic.lean

Remove eq_and_eq_of_le_of_le_of_mul_le as it's just one direction of mul_le_mul_iff_of_ge but with more assumptions.

Algebra/Order/Ring/Lemmas.lean

Generalize two versions of mul_eq_mul_iff_eq_and_eq_of_pos
Golfs

Changes to Algebra/Group/UniqueProds.lean and Algebra/MonoidAlgebra/NoZeroDivisors.lean are in declarations that will be removed by #6723.

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

9476eae9

Diff

@@ -89,6 +89,7 @@ variable [Preorder α]
 section AddCommSemigroup
 
 variable [AddCommSemigroup α] [Sub α] [OrderedSub α] {a b c d : α}
+/- TODO: Most results can be generalized to [Add α] [IsSymmOp α α (· + ·)] -/
 
 theorem tsub_le_iff_left : a - b ≤ c ↔ a ≤ b + c := by rw [tsub_le_iff_right, add_comm]
 #align tsub_le_iff_left tsub_le_iff_left

de29c328

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -247,7 +247,7 @@ variable [AddCommMonoid α] [Sub α] [OrderedSub α] {a b c d : α}
 theorem tsub_nonpos : a - b ≤ 0 ↔ a ≤ b := by rw [tsub_le_iff_left, add_zero]
 #align tsub_nonpos tsub_nonpos
 
-alias tsub_nonpos ↔ _ tsub_nonpos_of_le
+alias ⟨_, tsub_nonpos_of_le⟩ := tsub_nonpos
 #align tsub_nonpos_of_le tsub_nonpos_of_le
 
 end Preorder

de29c328

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

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

This has nice performance benefits.

32de3f67

Diff

@@ -44,7 +44,7 @@ TODO: generalize `Nat.le_of_le_of_sub_le_sub_right`, `Nat.sub_le_sub_right_iff`,
 -/
 
 
-variable {α β : Type _}
+variable {α β : Type*}
 
 /-- `OrderedSub α` means that `α` has a subtraction characterized by `a - b ≤ c ↔ a ≤ c + b`.
 In other words, `a - b` is the least `c` such that `a ≤ b + c`.
@@ -52,7 +52,7 @@ In other words, `a - b` is the least `c` such that `a ≤ b + c`.
 This is satisfied both by the subtraction in additive ordered groups and by truncated subtraction
 in canonically ordered monoids on many specific types.
 -/
-class OrderedSub (α : Type _) [LE α] [Add α] [Sub α] : Prop where
+class OrderedSub (α : Type*) [LE α] [Add α] [Sub α] : Prop where
   /-- `a - b` provides a lower bound on `c` such that `a ≤ c + b`. -/
   tsub_le_iff_right : ∀ a b c : α, a - b ≤ c ↔ a ≤ c + b
 #align has_ordered_sub OrderedSub

de29c328

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
-
-! This file was ported from Lean 3 source module algebra.order.sub.defs
-! leanprover-community/mathlib commit de29c328903507bb7aff506af9135f4bdaf1849c
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.CovariantAndContravariant
 import Mathlib.Algebra.Group.Basic
 import Mathlib.Algebra.Order.Monoid.Lemmas
 import Mathlib.Order.Lattice
 
+#align_import algebra.order.sub.defs from "leanprover-community/mathlib"@"de29c328903507bb7aff506af9135f4bdaf1849c"
+
 /-!
 # Ordered Subtraction

de29c328

chore: fix #align lines (#3640)

This PR fixes two things:

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

2b42dc7c

Diff

@@ -170,7 +170,6 @@ theorem tsub_tsub_le_tsub_add {a b c : α} : a - (b - c) ≤ a - b + c :=
       a ≤ a - b + b := le_tsub_add
       _ ≤ a - b + (c + (b - c)) := add_le_add_left le_add_tsub _
       _ = a - b + c + (b - c) := (add_assoc _ _ _).symm
-
 #align tsub_tsub_le_tsub_add tsub_tsub_le_tsub_add
 
 /-- See `tsub_add_tsub_comm` for the equality. -/
@@ -264,9 +263,7 @@ variable [PartialOrder α] [AddCommSemigroup α] [Sub α] [OrderedSub α] {a b c
 theorem tsub_tsub (b a c : α) : b - a - c = b - (a + c) := by
   apply le_antisymm
   · rw [tsub_le_iff_left, tsub_le_iff_left, ← add_assoc, ← tsub_le_iff_left]
-
   · rw [tsub_le_iff_left, add_assoc, ← tsub_le_iff_left, ← tsub_le_iff_left]
-
 #align tsub_tsub tsub_tsub
 
 theorem tsub_add_eq_tsub_tsub (a b c : α) : a - (b + c) = a - b - c :=
@@ -280,7 +277,6 @@ theorem tsub_add_eq_tsub_tsub_swap (a b c : α) : a - (b + c) = a - c - b := by
 
 theorem tsub_right_comm : a - b - c = a - c - b := by
   rw [←tsub_add_eq_tsub_tsub, tsub_add_eq_tsub_tsub_swap]
-
 #align tsub_right_comm tsub_right_comm
 
 /-! ### Lemmas that assume that an element is `AddLECancellable`. -/

de29c328

chore: forward port mathlib#18810, 18798, 18738 (#3443)

algebra.order.sub.defs, data.real.nnreal: leanprover-community/mathlib#18810, which is itself a backport. Also fixes a docstring typo.
linear_algebra.matrix.dot_product: leanprover-community/mathlib#18798
data.matrix.basic: leanprover-community/mathlib#18738

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

e978148f

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
 
 ! This file was ported from Lean 3 source module algebra.order.sub.defs
-! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
+! leanprover-community/mathlib commit de29c328903507bb7aff506af9135f4bdaf1849c
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -55,7 +55,6 @@ In other words, `a - b` is the least `c` such that `a ≤ b + c`.
 This is satisfied both by the subtraction in additive ordered groups and by truncated subtraction
 in canonically ordered monoids on many specific types.
 -/
--- porting note: changed to be a `Prop`
 class OrderedSub (α : Type _) [LE α] [Add α] [Sub α] : Prop where
   /-- `a - b` provides a lower bound on `c` such that `a ≤ c + b`. -/
   tsub_le_iff_right : ∀ a b c : α, a - b ≤ c ↔ a ≤ c + b

70d50ecf

fix: OrderedSub should be a Prop (#3436)

This mistake was present in mathlib3 too.

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

1b5c5dc9

Diff

@@ -55,7 +55,8 @@ In other words, `a - b` is the least `c` such that `a ≤ b + c`.
 This is satisfied both by the subtraction in additive ordered groups and by truncated subtraction
 in canonically ordered monoids on many specific types.
 -/
-class OrderedSub (α : Type _) [LE α] [Add α] [Sub α] where
+-- porting note: changed to be a `Prop`
+class OrderedSub (α : Type _) [LE α] [Add α] [Sub α] : Prop where
   /-- `a - b` provides a lower bound on `c` such that `a ≤ c + b`. -/
   tsub_le_iff_right : ∀ a b c : α, a - b ≤ c ↔ a ≤ c + b
 #align has_ordered_sub OrderedSub

70d50ecf

chore: add missing #align statements (#1902)

This PR is the result of a slight variant on the following "algorithm"

take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
for pairs that do not have an align statement:
- use Lean 4 to lookup the file + position of the Lean 4 name
- add an #align statement just before the next empty line
manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

b72bb858

Diff

@@ -252,6 +252,7 @@ theorem tsub_nonpos : a - b ≤ 0 ↔ a ≤ b := by rw [tsub_le_iff_left, add_ze
 #align tsub_nonpos tsub_nonpos
 
 alias tsub_nonpos ↔ _ tsub_nonpos_of_le
+#align tsub_nonpos_of_le tsub_nonpos_of_le
 
 end Preorder

70d50ecf

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

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

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2021 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn
+
+! This file was ported from Lean 3 source module algebra.order.sub.defs
+! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.CovariantAndContravariant
 import Mathlib.Algebra.Group.Basic

`algebra.order.sub.defs` ⟷ `Mathlib.Algebra.Order.Sub.Defs`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 26

algebra.order.sub.defs ⟷ Mathlib.Algebra.Order.Sub.Defs

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 26

`algebra.order.sub.defs` ⟷ `Mathlib.Algebra.Order.Sub.Defs`