algebra.order.monoid.with_top | Mathlib porting status

(last sync)

chore(order/with_bot): lemmas about unbot and untop (#18582)

Diff

@@ -11,7 +11,8 @@ import data.nat.cast.defs
 /-! # Adjoining top/bottom elements to ordered monoids.
 
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
-> Any changes to this file require a corresponding PR to mathlib4.-/
+> Any changes to this file require a corresponding PR to mathlib4.
+-/
 
 universes u v
 variables {α : Type u} {β : Type v}
@@ -31,6 +32,9 @@ variables [has_one α]
 @[simp, norm_cast, to_additive] lemma coe_eq_one {a : α} : (a : with_top α) = 1 ↔ a = 1 :=
 coe_eq_coe
 
+@[simp, to_additive] lemma untop_one : (1 : with_top α).untop coe_ne_top = 1 := rfl
+@[simp, to_additive] lemma untop_one' (d : α) : (1 : with_top α).untop' d = 1 := rfl
+
 @[simp, norm_cast, to_additive coe_nonneg]
 lemma one_le_coe [has_le α] {a : α} : 1 ≤ (a : with_top α) ↔ 1 ≤ a := coe_le_coe
 
@@ -347,6 +351,9 @@ lemma coe_one [has_one α] : ((1 : α) : with_bot α) = 1 := rfl
 lemma coe_eq_one [has_one α] {a : α} : (a : with_bot α) = 1 ↔ a = 1 :=
 with_top.coe_eq_one
 
+@[simp, to_additive] lemma unbot_one [has_one α] : (1 : with_bot α).unbot coe_ne_bot = 1 := rfl
+@[simp, to_additive] lemma unbot_one' [has_one α] (d : α) : (1 : with_bot α).unbot' d = 1 := rfl
+
 @[simp, norm_cast, to_additive coe_nonneg]
 lemma one_le_coe [has_one α] [has_le α] {a : α} : 1 ≤ (a : with_bot α) ↔ 1 ≤ a := coe_le_coe

feat(*/with_top): add lemmas about with_top/with_bot (#18487)

Backport leanprover-community/mathlib4#2406

Diff

@@ -74,8 +74,8 @@ by cases a; cases b; simp [none_eq_top, some_eq_coe, ←with_top.coe_add]
 
 lemma add_ne_top : a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ := add_eq_top.not.trans not_or_distrib
 
-lemma add_lt_top [partial_order α] {a b : with_top α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ :=
-by simp_rw [lt_top_iff_ne_top, add_ne_top]
+lemma add_lt_top [has_lt α] {a b : with_top α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ :=
+by simp_rw [with_top.lt_top_iff_ne_top, add_ne_top]
 
 lemma add_eq_coe : ∀ {a b : with_top α} {c : α},
   a + b = c ↔ ∃ (a' b' : α), ↑a' = a ∧ ↑b' = b ∧ a' + b' = c
@@ -380,7 +380,7 @@ lemma coe_bit1 [has_one α] {a : α} : ((bit1 a : α) : with_bot α) = bit1 a :=
 @[simp] lemma add_eq_bot : a + b = ⊥ ↔ a = ⊥ ∨ b = ⊥ := with_top.add_eq_top
 lemma add_ne_bot : a + b ≠ ⊥ ↔ a ≠ ⊥ ∧ b ≠ ⊥ := with_top.add_ne_top
 
-lemma bot_lt_add [partial_order α] {a b : with_bot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b :=
+lemma bot_lt_add [has_lt α] {a b : with_bot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b :=
 @with_top.add_lt_top αᵒᵈ _ _ _ _
 
 lemma add_eq_coe : a + b = x ↔ ∃ (a' b' : α), ↑a' = a ∧ ↑b' = b ∧ a' + b' = x := with_top.add_eq_coe

e7e2ba8a

feat(algebra/order/ring/with_top): ring covariance & ordered ring typeclasses for with_bot (#18149)

mathlib4 PR: https://github.com/leanprover-community/mathlib4/pull/1508

Diff

@@ -31,6 +31,12 @@ variables [has_one α]
 @[simp, norm_cast, to_additive] lemma coe_eq_one {a : α} : (a : with_top α) = 1 ↔ a = 1 :=
 coe_eq_coe
 
+@[simp, norm_cast, to_additive coe_nonneg]
+lemma one_le_coe [has_le α] {a : α} : 1 ≤ (a : with_top α) ↔ 1 ≤ a := coe_le_coe
+
+@[simp, norm_cast, to_additive coe_le_zero]
+lemma coe_le_one [has_le α] {a : α} : (a : with_top α) ≤ 1 ↔ a ≤ 1 := coe_le_coe
+
 @[simp, norm_cast, to_additive coe_pos]
 lemma one_lt_coe [has_lt α] {a : α} : 1 < (a : with_top α) ↔ 1 < a := coe_lt_coe
 
@@ -341,13 +347,19 @@ lemma coe_one [has_one α] : ((1 : α) : with_bot α) = 1 := rfl
 lemma coe_eq_one [has_one α] {a : α} : (a : with_bot α) = 1 ↔ a = 1 :=
 with_top.coe_eq_one
 
-@[norm_cast, to_additive coe_pos]
+@[simp, norm_cast, to_additive coe_nonneg]
+lemma one_le_coe [has_one α] [has_le α] {a : α} : 1 ≤ (a : with_bot α) ↔ 1 ≤ a := coe_le_coe
+
+@[simp, norm_cast, to_additive coe_le_zero]
+lemma coe_le_one [has_one α] [has_le α] {a : α} : (a : with_bot α) ≤ 1 ↔ a ≤ 1 := coe_le_coe
+
+@[simp, norm_cast, to_additive coe_pos]
 lemma one_lt_coe [has_one α] [has_lt α] {a : α} : 1 < (a : with_bot α) ↔ 1 < a := coe_lt_coe
 
-@[norm_cast, to_additive coe_lt_zero]
+@[simp, norm_cast, to_additive coe_lt_zero]
 lemma coe_lt_one [has_one α] [has_lt α] {a : α} : (a : with_bot α) < 1 ↔ a < 1 := coe_lt_coe
 
-@[to_additive] protected lemma map_one {β} [has_one α] (f : α → β) :
+@[simp, to_additive] protected lemma map_one {β} [has_one α] (f : α → β) :
   (1 : with_bot α).map f = (f 1 : with_bot β) := rfl
 
 @[norm_cast] lemma coe_nat [add_monoid_with_one α] (n : ℕ) : ((n : α) : with_bot α) = n := rfl

995b47e5

refactor(*): use option.map₂ (#18081)

Relevant parts are forward-ported as leanprover-community/mathlib4#1439

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

Diff

@@ -54,7 +54,7 @@ end has_one
 section has_add
 variables [has_add α] {a b c d : with_top α} {x y : α}
 
-instance : has_add (with_top α) := ⟨λ o₁ o₂, o₁.bind $ λ a, o₂.map $ (+) a⟩
+instance : has_add (with_top α) := ⟨option.map₂ (+)⟩
 
 @[norm_cast] lemma coe_add : ((x + y : α) : with_top α) = x + y := rfl
 @[norm_cast] lemma coe_bit0 : ((bit0 x : α) : with_top α) = bit0 x := rfl
@@ -201,35 +201,16 @@ end
 end has_add
 
 instance [add_semigroup α] : add_semigroup (with_top α) :=
-{ add_assoc := begin
-    repeat { refine with_top.rec_top_coe _ _; try { intro }};
-    simp [←with_top.coe_add, add_assoc]
-  end,
+{ add_assoc := λ _ _ _, option.map₂_assoc add_assoc,
   ..with_top.has_add }
 
 instance [add_comm_semigroup α] : add_comm_semigroup (with_top α) :=
-{ add_comm :=
-  begin
-    repeat { refine with_top.rec_top_coe _ _; try { intro }};
-    simp [←with_top.coe_add, add_comm]
-  end,
+{ add_comm := λ _ _, option.map₂_comm add_comm,
   ..with_top.add_semigroup }
 
 instance [add_zero_class α] : add_zero_class (with_top α) :=
-{ zero_add :=
-  begin
-    refine with_top.rec_top_coe _ _,
-    { simp },
-    { intro,
-      rw [←with_top.coe_zero, ←with_top.coe_add, zero_add] }
-  end,
-  add_zero :=
-  begin
-    refine with_top.rec_top_coe _ _,
-    { simp },
-    { intro,
-      rw [←with_top.coe_zero, ←with_top.coe_add, add_zero] }
-  end,
+{ zero_add := option.map₂_left_identity zero_add,
+  add_zero := option.map₂_right_identity add_zero,
   ..with_top.has_zero,
   ..with_top.has_add }

(no changes)

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-25-08

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

ad7a2212

Diff

@@ -5,7 +5,7 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
 import Algebra.Group.Hom.Defs
 import Algebra.Order.Monoid.OrderDual
-import Algebra.Order.Monoid.WithZero.Basic
+import Algebra.Order.GroupWithZero.Canonical
 import Data.Nat.Cast.Defs
 
 #align_import algebra.order.monoid.with_top from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"

bump to nightly-2024-04-09-08

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

659ec6f7

Diff

@@ -433,25 +433,25 @@ instance [CanonicallyLinearOrderedAddCommMonoid α] :
     CanonicallyLinearOrderedAddCommMonoid (WithTop α) :=
   { WithTop.canonicallyOrderedAddMonoid, WithTop.linearOrder with }
 
-#print WithTop.coe_nat /-
+#print WithTop.coe_natCast /-
 @[simp, norm_cast]
-theorem coe_nat [AddMonoidWithOne α] (n : ℕ) : ((n : α) : WithTop α) = n :=
+theorem coe_natCast [AddMonoidWithOne α] (n : ℕ) : ((n : α) : WithTop α) = n :=
   rfl
-#align with_top.coe_nat WithTop.coe_nat
+#align with_top.coe_nat WithTop.coe_natCast
 -/
 
-#print WithTop.nat_ne_top /-
+#print WithTop.natCast_ne_top /-
 @[simp]
-theorem nat_ne_top [AddMonoidWithOne α] (n : ℕ) : (n : WithTop α) ≠ ⊤ :=
+theorem natCast_ne_top [AddMonoidWithOne α] (n : ℕ) : (n : WithTop α) ≠ ⊤ :=
   coe_ne_top
-#align with_top.nat_ne_top WithTop.nat_ne_top
+#align with_top.nat_ne_top WithTop.natCast_ne_top
 -/
 
-#print WithTop.top_ne_nat /-
+#print WithTop.top_ne_natCast /-
 @[simp]
-theorem top_ne_nat [AddMonoidWithOne α] (n : ℕ) : (⊤ : WithTop α) ≠ n :=
+theorem top_ne_natCast [AddMonoidWithOne α] (n : ℕ) : (⊤ : WithTop α) ≠ n :=
   top_ne_coe
-#align with_top.top_ne_nat WithTop.top_ne_nat
+#align with_top.top_ne_nat WithTop.top_ne_natCast
 -/
 
 #print WithTop.addHom /-
@@ -622,25 +622,25 @@ protected theorem map_one {β} [One α] (f : α → β) : (1 : WithBot α).map f
 #align with_bot.map_zero WithBot.map_zero
 -/
 
-#print WithBot.coe_nat /-
+#print WithBot.coe_natCast /-
 @[norm_cast]
-theorem coe_nat [AddMonoidWithOne α] (n : ℕ) : ((n : α) : WithBot α) = n :=
+theorem coe_natCast [AddMonoidWithOne α] (n : ℕ) : ((n : α) : WithBot α) = n :=
   rfl
-#align with_bot.coe_nat WithBot.coe_nat
+#align with_bot.coe_nat WithBot.coe_natCast
 -/
 
-#print WithBot.nat_ne_bot /-
+#print WithBot.natCast_ne_bot /-
 @[simp]
-theorem nat_ne_bot [AddMonoidWithOne α] (n : ℕ) : (n : WithBot α) ≠ ⊥ :=
+theorem natCast_ne_bot [AddMonoidWithOne α] (n : ℕ) : (n : WithBot α) ≠ ⊥ :=
   coe_ne_bot
-#align with_bot.nat_ne_bot WithBot.nat_ne_bot
+#align with_bot.nat_ne_bot WithBot.natCast_ne_bot
 -/
 
-#print WithBot.bot_ne_nat /-
+#print WithBot.bot_ne_natCast /-
 @[simp]
-theorem bot_ne_nat [AddMonoidWithOne α] (n : ℕ) : (⊥ : WithBot α) ≠ n :=
+theorem bot_ne_natCast [AddMonoidWithOne α] (n : ℕ) : (⊥ : WithBot α) ≠ n :=
   bot_ne_coe
-#align with_bot.bot_ne_nat WithBot.bot_ne_nat
+#align with_bot.bot_ne_nat WithBot.bot_ne_natCast
 -/
 
 section Add

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Algebra.Hom.Group
+import Algebra.Group.Hom.Defs
 import Algebra.Order.Monoid.OrderDual
 import Algebra.Order.Monoid.WithZero.Basic
 import Data.Nat.Cast.Defs

bump to nightly-2024-01-10-06

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

32726bc2

Diff

@@ -461,10 +461,12 @@ def addHom [AddMonoid α] : α →+ WithTop α :=
 #align with_top.coe_add_hom WithTop.addHom
 -/
 
+#print WithTop.coe_addHom /-
 @[simp]
 theorem coe_addHom [AddMonoid α] : ⇑(addHom : α →+ WithTop α) = coe :=
   rfl
 #align with_top.coe_coe_add_hom WithTop.coe_addHom
+-/
 
 #print WithTop.zero_lt_top /-
 @[simp]

bump to nightly-2023-10-07-06

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

d191b687

Diff

@@ -420,7 +420,7 @@ instance [LE α] [Add α] [ExistsAddOfLE α] : ExistsAddOfLE (WithTop α) :=
       exact ⟨c, rfl⟩
     | ⊤, (b : α) => fun h => (not_top_le_coe _ h).elim⟩
 
-instance [CanonicallyOrderedAddMonoid α] : CanonicallyOrderedAddMonoid (WithTop α) :=
+instance [CanonicallyOrderedAddCommMonoid α] : CanonicallyOrderedAddCommMonoid (WithTop α) :=
   { WithTop.orderBot, WithTop.orderedAddCommMonoid, WithTop.existsAddOfLE with
     le_self_add := fun a b =>
       match a, b with
@@ -429,7 +429,8 @@ instance [CanonicallyOrderedAddMonoid α] : CanonicallyOrderedAddMonoid (WithTop
       | (a : α), (b : α) => WithTop.coe_le_coe.2 le_self_add
       | ⊤, (b : α) => le_rfl }
 
-instance [CanonicallyLinearOrderedAddMonoid α] : CanonicallyLinearOrderedAddMonoid (WithTop α) :=
+instance [CanonicallyLinearOrderedAddCommMonoid α] :
+    CanonicallyLinearOrderedAddCommMonoid (WithTop α) :=
   { WithTop.canonicallyOrderedAddMonoid, WithTop.linearOrder with }
 
 #print WithTop.coe_nat /-

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) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Mathbin.Algebra.Hom.Group
-import Mathbin.Algebra.Order.Monoid.OrderDual
-import Mathbin.Algebra.Order.Monoid.WithZero.Basic
-import Mathbin.Data.Nat.Cast.Defs
+import Algebra.Hom.Group
+import Algebra.Order.Monoid.OrderDual
+import Algebra.Order.Monoid.WithZero.Basic
+import Data.Nat.Cast.Defs
 
 #align_import algebra.order.monoid.with_top from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"

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) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
-
-! This file was ported from Lean 3 source module algebra.order.monoid.with_top
-! leanprover-community/mathlib commit 0111834459f5d7400215223ea95ae38a1265a907
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Hom.Group
 import Mathbin.Algebra.Order.Monoid.OrderDual
 import Mathbin.Algebra.Order.Monoid.WithZero.Basic
 import Mathbin.Data.Nat.Cast.Defs
 
+#align_import algebra.order.monoid.with_top from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
+
 /-! # Adjoining top/bottom elements to ordered monoids.
 
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -68,35 +68,45 @@ theorem untop_one' (d : α) : (1 : WithTop α).untop' d = 1 :=
 #align with_top.untop_zero' WithTop.untop_zero'
 -/
 
+#print WithTop.one_le_coe /-
 @[simp, norm_cast, to_additive coe_nonneg]
 theorem one_le_coe [LE α] {a : α} : 1 ≤ (a : WithTop α) ↔ 1 ≤ a :=
   coe_le_coe
 #align with_top.one_le_coe WithTop.one_le_coe
 #align with_top.coe_nonneg WithTop.coe_nonneg
+-/
 
+#print WithTop.coe_le_one /-
 @[simp, norm_cast, to_additive coe_le_zero]
 theorem coe_le_one [LE α] {a : α} : (a : WithTop α) ≤ 1 ↔ a ≤ 1 :=
   coe_le_coe
 #align with_top.coe_le_one WithTop.coe_le_one
 #align with_top.coe_le_zero WithTop.coe_le_zero
+-/
 
+#print WithTop.one_lt_coe /-
 @[simp, norm_cast, to_additive coe_pos]
 theorem one_lt_coe [LT α] {a : α} : 1 < (a : WithTop α) ↔ 1 < a :=
   coe_lt_coe
 #align with_top.one_lt_coe WithTop.one_lt_coe
 #align with_top.coe_pos WithTop.coe_pos
+-/
 
+#print WithTop.coe_lt_one /-
 @[simp, norm_cast, to_additive coe_lt_zero]
 theorem coe_lt_one [LT α] {a : α} : (a : WithTop α) < 1 ↔ a < 1 :=
   coe_lt_coe
 #align with_top.coe_lt_one WithTop.coe_lt_one
 #align with_top.coe_lt_zero WithTop.coe_lt_zero
+-/
 
+#print WithTop.map_one /-
 @[simp, to_additive]
 protected theorem map_one {β} (f : α → β) : (1 : WithTop α).map f = (f 1 : WithTop β) :=
   rfl
 #align with_top.map_one WithTop.map_one
 #align with_top.map_zero WithTop.map_zero
+-/
 
 #print WithTop.one_eq_coe /-
 @[simp, norm_cast, to_additive]
@@ -181,9 +191,11 @@ theorem add_ne_top : a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ :=
 #align with_top.add_ne_top WithTop.add_ne_top
 -/
 
+#print WithTop.add_lt_top /-
 theorem add_lt_top [LT α] {a b : WithTop α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ := by
   simp_rw [WithTop.lt_top_iff_ne_top, add_ne_top]
 #align with_top.add_lt_top WithTop.add_lt_top
+-/
 
 #print WithTop.add_eq_coe /-
 theorem add_eq_coe :
@@ -209,6 +221,7 @@ theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ := by
 #align with_top.coe_add_eq_top_iff WithTop.coe_add_eq_top_iff
 -/
 
+#print WithTop.covariantClass_add_le /-
 instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (· + ·) (· ≤ ·) :=
   ⟨fun a b c h => by
@@ -216,7 +229,9 @@ instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ 
     rcases le_coe_iff.1 h with ⟨b, rfl, h'⟩
     exact coe_le_coe.2 (add_le_add_left (coe_le_coe.1 h) _)⟩
 #align with_top.covariant_class_add_le WithTop.covariantClass_add_le
+-/
 
+#print WithTop.covariantClass_swap_add_le /-
 instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· ≤ ·) :=
   ⟨fun a b c h => by
@@ -224,7 +239,9 @@ instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·
     rcases le_coe_iff.1 h with ⟨b, rfl, h'⟩
     exact coe_le_coe.2 (add_le_add_right (coe_le_coe.1 h) _)⟩
 #align with_top.covariant_class_swap_add_le WithTop.covariantClass_swap_add_le
+-/
 
+#print WithTop.contravariantClass_add_lt /-
 instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithTop α) (WithTop α) (· + ·) (· < ·) :=
   ⟨fun a b c h => by
@@ -234,7 +251,9 @@ instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (
     · exact coe_lt_top _
     · exact coe_lt_coe.2 (lt_of_add_lt_add_left <| coe_lt_coe.1 h)⟩
 #align with_top.contravariant_class_add_lt WithTop.contravariantClass_add_lt
+-/
 
+#print WithTop.contravariantClass_swap_add_lt /-
 instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap (· + ·)) (· < ·)] :
     ContravariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· < ·) :=
   ⟨fun a b c h => by
@@ -243,7 +262,9 @@ instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap
     · exact coe_lt_top _
     · exact coe_lt_coe.2 (lt_of_add_lt_add_right <| coe_lt_coe.1 h)⟩
 #align with_top.contravariant_class_swap_add_lt WithTop.contravariantClass_swap_add_lt
+-/
 
+#print WithTop.le_of_add_le_add_left /-
 protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤)
     (h : a + b ≤ a + c) : b ≤ c := by
   lift a to α using ha
@@ -252,7 +273,9 @@ protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· +
   simp only [← coe_add, coe_le_coe] at h ⊢
   exact le_of_add_le_add_left h
 #align with_top.le_of_add_le_add_left WithTop.le_of_add_le_add_left
+-/
 
+#print WithTop.le_of_add_le_add_right /-
 protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊤) (h : b + a ≤ c + a) : b ≤ c :=
   by
@@ -263,7 +286,9 @@ protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap
   · exact (not_top_le_coe _ h).elim
   · exact coe_le_coe.2 (le_of_add_le_add_right <| coe_le_coe.1 h)
 #align with_top.le_of_add_le_add_right WithTop.le_of_add_le_add_right
+-/
 
+#print WithTop.add_lt_add_left /-
 protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : a + b < a + c := by
   lift a to α using ha
@@ -272,7 +297,9 @@ protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· <
   · exact coe_lt_top _
   · exact coe_lt_coe.2 (add_lt_add_left (coe_lt_coe.1 h) _)
 #align with_top.add_lt_add_left WithTop.add_lt_add_left
+-/
 
+#print WithTop.add_lt_add_right /-
 protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : b + a < c + a := by
   lift a to α using ha
@@ -281,26 +308,35 @@ protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)
   · exact coe_lt_top _
   · exact coe_lt_coe.2 (add_lt_add_right (coe_lt_coe.1 h) _)
 #align with_top.add_lt_add_right WithTop.add_lt_add_right
+-/
 
+#print WithTop.add_le_add_iff_left /-
 protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (· ≤ ·)]
     [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤) : a + b ≤ a + c ↔ b ≤ c :=
   ⟨WithTop.le_of_add_le_add_left ha, fun h => add_le_add_left h a⟩
 #align with_top.add_le_add_iff_left WithTop.add_le_add_iff_left
+-/
 
+#print WithTop.add_le_add_iff_right /-
 protected theorem add_le_add_iff_right [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
     [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) : b + a ≤ c + a ↔ b ≤ c :=
   ⟨WithTop.le_of_add_le_add_right ha, fun h => add_le_add_right h a⟩
 #align with_top.add_le_add_iff_right WithTop.add_le_add_iff_right
+-/
 
+#print WithTop.add_lt_add_iff_left /-
 protected theorem add_lt_add_iff_left [LT α] [CovariantClass α α (· + ·) (· < ·)]
     [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤) : a + b < a + c ↔ b < c :=
   ⟨lt_of_add_lt_add_left, WithTop.add_lt_add_left ha⟩
 #align with_top.add_lt_add_iff_left WithTop.add_lt_add_iff_left
+-/
 
+#print WithTop.add_lt_add_iff_right /-
 protected theorem add_lt_add_iff_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)]
     [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤) : b + a < c + a ↔ b < c :=
   ⟨lt_of_add_lt_add_right, WithTop.add_lt_add_right ha⟩
 #align with_top.add_lt_add_iff_right WithTop.add_lt_add_iff_right
+-/
 
 #print WithTop.add_lt_add_of_le_of_lt /-
 protected theorem add_lt_add_of_le_of_lt [Preorder α] [CovariantClass α α (· + ·) (· < ·)]
@@ -318,6 +354,7 @@ protected theorem add_lt_add_of_lt_of_le [Preorder α] [CovariantClass α α (·
 #align with_top.add_lt_add_of_lt_of_le WithTop.add_lt_add_of_lt_of_le
 -/
 
+#print WithTop.map_add /-
 --  There is no `with_top.map_mul_of_mul_hom`, since `with_top` does not have a multiplication.
 @[simp]
 protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : WithTop α) :
@@ -330,6 +367,7 @@ protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : With
     · rw [map_coe, map_coe, ← coe_add, ← coe_add, ← map_add]
       rfl
 #align with_top.map_add WithTop.map_add
+-/
 
 end Add
 
@@ -430,15 +468,19 @@ theorem coe_addHom [AddMonoid α] : ⇑(addHom : α →+ WithTop α) = coe :=
   rfl
 #align with_top.coe_coe_add_hom WithTop.coe_addHom
 
+#print WithTop.zero_lt_top /-
 @[simp]
 theorem zero_lt_top [OrderedAddCommMonoid α] : (0 : WithTop α) < ⊤ :=
   coe_lt_top 0
 #align with_top.zero_lt_top WithTop.zero_lt_top
+-/
 
+#print WithTop.zero_lt_coe /-
 @[simp, norm_cast]
 theorem zero_lt_coe [OrderedAddCommMonoid α] (a : α) : (0 : WithTop α) < a ↔ 0 < a :=
   coe_lt_coe
 #align with_top.zero_lt_coe WithTop.zero_lt_coe
+-/
 
 #print OneHom.withTopMap /-
 /-- A version of `with_top.map` for `one_hom`s. -/
@@ -540,35 +582,45 @@ theorem unbot_one' [One α] (d : α) : (1 : WithBot α).unbot' d = 1 :=
 #align with_bot.unbot_zero' WithBot.unbot_zero'
 -/
 
+#print WithBot.one_le_coe /-
 @[simp, norm_cast, to_additive coe_nonneg]
 theorem one_le_coe [One α] [LE α] {a : α} : 1 ≤ (a : WithBot α) ↔ 1 ≤ a :=
   coe_le_coe
 #align with_bot.one_le_coe WithBot.one_le_coe
 #align with_bot.coe_nonneg WithBot.coe_nonneg
+-/
 
+#print WithBot.coe_le_one /-
 @[simp, norm_cast, to_additive coe_le_zero]
 theorem coe_le_one [One α] [LE α] {a : α} : (a : WithBot α) ≤ 1 ↔ a ≤ 1 :=
   coe_le_coe
 #align with_bot.coe_le_one WithBot.coe_le_one
 #align with_bot.coe_le_zero WithBot.coe_le_zero
+-/
 
+#print WithBot.one_lt_coe /-
 @[simp, norm_cast, to_additive coe_pos]
 theorem one_lt_coe [One α] [LT α] {a : α} : 1 < (a : WithBot α) ↔ 1 < a :=
   coe_lt_coe
 #align with_bot.one_lt_coe WithBot.one_lt_coe
 #align with_bot.coe_pos WithBot.coe_pos
+-/
 
+#print WithBot.coe_lt_one /-
 @[simp, norm_cast, to_additive coe_lt_zero]
 theorem coe_lt_one [One α] [LT α] {a : α} : (a : WithBot α) < 1 ↔ a < 1 :=
   coe_lt_coe
 #align with_bot.coe_lt_one WithBot.coe_lt_one
 #align with_bot.coe_lt_zero WithBot.coe_lt_zero
+-/
 
+#print WithBot.map_one /-
 @[simp, to_additive]
 protected theorem map_one {β} [One α] (f : α → β) : (1 : WithBot α).map f = (f 1 : WithBot β) :=
   rfl
 #align with_bot.map_one WithBot.map_one
 #align with_bot.map_zero WithBot.map_zero
+-/
 
 #print WithBot.coe_nat /-
 @[norm_cast]
@@ -640,9 +692,11 @@ theorem add_ne_bot : a + b ≠ ⊥ ↔ a ≠ ⊥ ∧ b ≠ ⊥ :=
 #align with_bot.add_ne_bot WithBot.add_ne_bot
 -/
 
+#print WithBot.bot_lt_add /-
 theorem bot_lt_add [LT α] {a b : WithBot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b :=
   @WithTop.add_lt_top αᵒᵈ _ _ _ _
 #align with_bot.bot_lt_add WithBot.bot_lt_add
+-/
 
 #print WithBot.add_eq_coe /-
 theorem add_eq_coe : a + b = x ↔ ∃ a' b' : α, ↑a' = a ∧ ↑b' = b ∧ a' + b' = x :=
@@ -664,12 +718,14 @@ theorem coe_add_eq_bot_iff : ↑x + b = ⊥ ↔ b = ⊥ :=
 #align with_bot.coe_add_eq_bot_iff WithBot.coe_add_eq_bot_iff
 -/
 
+#print WithBot.map_add /-
 --  There is no `with_bot.map_mul_of_mul_hom`, since `with_bot` does not have a multiplication.
 @[simp]
 protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : WithBot α) :
     (a + b).map f = a.map f + b.map f :=
   WithTop.map_add f a b
 #align with_bot.map_add WithBot.map_add
+-/
 
 #print OneHom.withBotMap /-
 /-- A version of `with_bot.map` for `one_hom`s. -/

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -249,7 +249,7 @@ protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· +
   lift a to α using ha
   induction c using WithTop.recTopCoe; · exact le_top
   induction b using WithTop.recTopCoe; · exact (not_top_le_coe _ h).elim
-  simp only [← coe_add, coe_le_coe] at h⊢
+  simp only [← coe_add, coe_le_coe] at h ⊢
   exact le_of_add_le_add_left h
 #align with_top.le_of_add_le_add_left WithTop.le_of_add_le_add_left
 
@@ -367,7 +367,7 @@ instance [OrderedAddCommMonoid α] : OrderedAddCommMonoid (WithTop α) :=
       rintro a b h (_ | c); · simp [none_eq_top]
       rcases b with (_ | b); · simp [none_eq_top]
       rcases le_coe_iff.1 h with ⟨a, rfl, h⟩
-      simp only [some_eq_coe, ← coe_add, coe_le_coe] at h⊢
+      simp only [some_eq_coe, ← coe_add, coe_le_coe] at h ⊢
       exact add_le_add_left h c }
 
 instance [LinearOrderedAddCommMonoid α] : LinearOrderedAddCommMonoidWithTop (WithTop α) :=

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -302,17 +302,21 @@ protected theorem add_lt_add_iff_right [LT α] [CovariantClass α α (swap (· +
   ⟨lt_of_add_lt_add_right, WithTop.add_lt_add_right ha⟩
 #align with_top.add_lt_add_iff_right WithTop.add_lt_add_iff_right
 
+#print WithTop.add_lt_add_of_le_of_lt /-
 protected theorem add_lt_add_of_le_of_lt [Preorder α] [CovariantClass α α (· + ·) (· < ·)]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) (hab : a ≤ b) (hcd : c < d) :
     a + c < b + d :=
   (WithTop.add_lt_add_left ha hcd).trans_le <| add_le_add_right hab _
 #align with_top.add_lt_add_of_le_of_lt WithTop.add_lt_add_of_le_of_lt
+-/
 
+#print WithTop.add_lt_add_of_lt_of_le /-
 protected theorem add_lt_add_of_lt_of_le [Preorder α] [CovariantClass α α (· + ·) (· ≤ ·)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (hc : c ≠ ⊤) (hab : a < b) (hcd : c ≤ d) :
     a + c < b + d :=
   (WithTop.add_lt_add_right hc hab).trans_le <| add_le_add_left hcd _
 #align with_top.add_lt_add_of_lt_of_le WithTop.add_lt_add_of_lt_of_le
+-/
 
 --  There is no `with_top.map_mul_of_mul_hom`, since `with_top` does not have a multiplication.
 @[simp]
@@ -700,77 +704,105 @@ protected def AddMonoidHom.withBotMap {M N : Type _} [AddZeroClass M] [AddZeroCl
 
 variable [Preorder α]
 
+#print WithBot.covariantClass_add_le /-
 instance covariantClass_add_le [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (· + ·) (· ≤ ·) :=
   @OrderDual.covariantClass_add_le (WithTop αᵒᵈ) _ _ _
 #align with_bot.covariant_class_add_le WithBot.covariantClass_add_le
+-/
 
+#print WithBot.covariantClass_swap_add_le /-
 instance covariantClass_swap_add_le [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· ≤ ·) :=
   @OrderDual.covariantClass_swap_add_le (WithTop αᵒᵈ) _ _ _
 #align with_bot.covariant_class_swap_add_le WithBot.covariantClass_swap_add_le
+-/
 
+#print WithBot.contravariantClass_add_lt /-
 instance contravariantClass_add_lt [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (· + ·) (· < ·) :=
   @OrderDual.contravariantClass_add_lt (WithTop αᵒᵈ) _ _ _
 #align with_bot.contravariant_class_add_lt WithBot.contravariantClass_add_lt
+-/
 
+#print WithBot.contravariantClass_swap_add_lt /-
 instance contravariantClass_swap_add_lt [ContravariantClass α α (swap (· + ·)) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· < ·) :=
   @OrderDual.contravariantClass_swap_add_lt (WithTop αᵒᵈ) _ _ _
 #align with_bot.contravariant_class_swap_add_lt WithBot.contravariantClass_swap_add_lt
+-/
 
+#print WithBot.le_of_add_le_add_left /-
 protected theorem le_of_add_le_add_left [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥)
     (h : a + b ≤ a + c) : b ≤ c :=
   @WithTop.le_of_add_le_add_left αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.le_of_add_le_add_left WithBot.le_of_add_le_add_left
+-/
 
+#print WithBot.le_of_add_le_add_right /-
 protected theorem le_of_add_le_add_right [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊥) (h : b + a ≤ c + a) : b ≤ c :=
   @WithTop.le_of_add_le_add_right αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.le_of_add_le_add_right WithBot.le_of_add_le_add_right
+-/
 
+#print WithBot.add_lt_add_left /-
 protected theorem add_lt_add_left [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) (h : b < c) :
     a + b < a + c :=
   @WithTop.add_lt_add_left αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.add_lt_add_left WithBot.add_lt_add_left
+-/
 
+#print WithBot.add_lt_add_right /-
 protected theorem add_lt_add_right [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥)
     (h : b < c) : b + a < c + a :=
   @WithTop.add_lt_add_right αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.add_lt_add_right WithBot.add_lt_add_right
+-/
 
+#print WithBot.add_le_add_iff_left /-
 protected theorem add_le_add_iff_left [CovariantClass α α (· + ·) (· ≤ ·)]
     [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥) : a + b ≤ a + c ↔ b ≤ c :=
   ⟨WithBot.le_of_add_le_add_left ha, fun h => add_le_add_left h a⟩
 #align with_bot.add_le_add_iff_left WithBot.add_le_add_iff_left
+-/
 
+#print WithBot.add_le_add_iff_right /-
 protected theorem add_le_add_iff_right [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
     [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊥) : b + a ≤ c + a ↔ b ≤ c :=
   ⟨WithBot.le_of_add_le_add_right ha, fun h => add_le_add_right h a⟩
 #align with_bot.add_le_add_iff_right WithBot.add_le_add_iff_right
+-/
 
+#print WithBot.add_lt_add_iff_left /-
 protected theorem add_lt_add_iff_left [CovariantClass α α (· + ·) (· < ·)]
     [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) : a + b < a + c ↔ b < c :=
   ⟨lt_of_add_lt_add_left, WithBot.add_lt_add_left ha⟩
 #align with_bot.add_lt_add_iff_left WithBot.add_lt_add_iff_left
+-/
 
+#print WithBot.add_lt_add_iff_right /-
 protected theorem add_lt_add_iff_right [CovariantClass α α (swap (· + ·)) (· < ·)]
     [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥) : b + a < c + a ↔ b < c :=
   ⟨lt_of_add_lt_add_right, WithBot.add_lt_add_right ha⟩
 #align with_bot.add_lt_add_iff_right WithBot.add_lt_add_iff_right
+-/
 
+#print WithBot.add_lt_add_of_le_of_lt /-
 protected theorem add_lt_add_of_le_of_lt [CovariantClass α α (· + ·) (· < ·)]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (hb : b ≠ ⊥) (hab : a ≤ b) (hcd : c < d) :
     a + c < b + d :=
   @WithTop.add_lt_add_of_le_of_lt αᵒᵈ _ _ _ _ _ _ _ _ hb hab hcd
 #align with_bot.add_lt_add_of_le_of_lt WithBot.add_lt_add_of_le_of_lt
+-/
 
+#print WithBot.add_lt_add_of_lt_of_le /-
 protected theorem add_lt_add_of_lt_of_le [CovariantClass α α (· + ·) (· ≤ ·)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (hd : d ≠ ⊥) (hab : a < b) (hcd : c ≤ d) :
     a + c < b + d :=
   @WithTop.add_lt_add_of_lt_of_le αᵒᵈ _ _ _ _ _ _ _ _ hd hab hcd
 #align with_bot.add_lt_add_of_lt_of_le WithBot.add_lt_add_of_lt_of_le
+-/
 
 end Add

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -68,60 +68,30 @@ theorem untop_one' (d : α) : (1 : WithTop α).untop' d = 1 :=
 #align with_top.untop_zero' WithTop.untop_zero'
 -/
 
-/- warning: with_top.one_le_coe -> WithTop.one_le_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LE.{u1} α] {a : α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} (WithTop.{u1} α) 1 (OfNat.mk.{u1} (WithTop.{u1} α) 1 (One.one.{u1} (WithTop.{u1} α) (WithTop.one.{u1} α _inst_1)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LE.{u1} α] {a : α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (OfNat.ofNat.{u1} (WithTop.{u1} α) 1 (One.toOfNat1.{u1} (WithTop.{u1} α) (WithTop.one.{u1} α _inst_1))) (WithTop.some.{u1} α a)) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align with_top.one_le_coe WithTop.one_le_coeₓ'. -/
 @[simp, norm_cast, to_additive coe_nonneg]
 theorem one_le_coe [LE α] {a : α} : 1 ≤ (a : WithTop α) ↔ 1 ≤ a :=
   coe_le_coe
 #align with_top.one_le_coe WithTop.one_le_coe
 #align with_top.coe_nonneg WithTop.coe_nonneg
 
-/- warning: with_top.coe_le_one -> WithTop.coe_le_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LE.{u1} α] {a : α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (OfNat.ofNat.{u1} (WithTop.{u1} α) 1 (OfNat.mk.{u1} (WithTop.{u1} α) 1 (One.one.{u1} (WithTop.{u1} α) (WithTop.one.{u1} α _inst_1))))) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LE.{u1} α] {a : α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (WithTop.some.{u1} α a) (OfNat.ofNat.{u1} (WithTop.{u1} α) 1 (One.toOfNat1.{u1} (WithTop.{u1} α) (WithTop.one.{u1} α _inst_1)))) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align with_top.coe_le_one WithTop.coe_le_oneₓ'. -/
 @[simp, norm_cast, to_additive coe_le_zero]
 theorem coe_le_one [LE α] {a : α} : (a : WithTop α) ≤ 1 ↔ a ≤ 1 :=
   coe_le_coe
 #align with_top.coe_le_one WithTop.coe_le_one
 #align with_top.coe_le_zero WithTop.coe_le_zero
 
-/- warning: with_top.one_lt_coe -> WithTop.one_lt_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LT.{u1} α] {a : α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} (WithTop.{u1} α) 1 (OfNat.mk.{u1} (WithTop.{u1} α) 1 (One.one.{u1} (WithTop.{u1} α) (WithTop.one.{u1} α _inst_1)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LT.{u1} α] {a : α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (OfNat.ofNat.{u1} (WithTop.{u1} α) 1 (One.toOfNat1.{u1} (WithTop.{u1} α) (WithTop.one.{u1} α _inst_1))) (WithTop.some.{u1} α a)) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align with_top.one_lt_coe WithTop.one_lt_coeₓ'. -/
 @[simp, norm_cast, to_additive coe_pos]
 theorem one_lt_coe [LT α] {a : α} : 1 < (a : WithTop α) ↔ 1 < a :=
   coe_lt_coe
 #align with_top.one_lt_coe WithTop.one_lt_coe
 #align with_top.coe_pos WithTop.coe_pos
 
-/- warning: with_top.coe_lt_one -> WithTop.coe_lt_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LT.{u1} α] {a : α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (OfNat.ofNat.{u1} (WithTop.{u1} α) 1 (OfNat.mk.{u1} (WithTop.{u1} α) 1 (One.one.{u1} (WithTop.{u1} α) (WithTop.one.{u1} α _inst_1))))) (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LT.{u1} α] {a : α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (WithTop.some.{u1} α a) (OfNat.ofNat.{u1} (WithTop.{u1} α) 1 (One.toOfNat1.{u1} (WithTop.{u1} α) (WithTop.one.{u1} α _inst_1)))) (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align with_top.coe_lt_one WithTop.coe_lt_oneₓ'. -/
 @[simp, norm_cast, to_additive coe_lt_zero]
 theorem coe_lt_one [LT α] {a : α} : (a : WithTop α) < 1 ↔ a < 1 :=
   coe_lt_coe
 #align with_top.coe_lt_one WithTop.coe_lt_one
 #align with_top.coe_lt_zero WithTop.coe_lt_zero
 
-/- warning: with_top.map_one -> WithTop.map_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] {β : Type.{u2}} (f : α -> β), Eq.{succ u2} (WithTop.{u2} β) (WithTop.map.{u1, u2} α β f (OfNat.ofNat.{u1} (WithTop.{u1} α) 1 (OfNat.mk.{u1} (WithTop.{u1} α) 1 (One.one.{u1} (WithTop.{u1} α) (WithTop.one.{u1} α _inst_1))))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (WithTop.{u2} β) (HasLiftT.mk.{succ u2, succ u2} β (WithTop.{u2} β) (CoeTCₓ.coe.{succ u2, succ u2} β (WithTop.{u2} β) (WithTop.hasCoeT.{u2} β))) (f (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : One.{u2} α] {β : Type.{u1}} (f : α -> β), Eq.{succ u1} (WithTop.{u1} β) (WithTop.map.{u2, u1} α β f (OfNat.ofNat.{u2} (WithTop.{u2} α) 1 (One.toOfNat1.{u2} (WithTop.{u2} α) (WithTop.one.{u2} α _inst_1)))) (WithTop.some.{u1} β (f (OfNat.ofNat.{u2} α 1 (One.toOfNat1.{u2} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align with_top.map_one WithTop.map_oneₓ'. -/
 @[simp, to_additive]
 protected theorem map_one {β} (f : α → β) : (1 : WithTop α).map f = (f 1 : WithTop β) :=
   rfl
@@ -211,12 +181,6 @@ theorem add_ne_top : a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ :=
 #align with_top.add_ne_top WithTop.add_ne_top
 -/
 
-/- warning: with_top.add_lt_top -> WithTop.add_lt_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (And (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (And (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))))
-Case conversion may be inaccurate. Consider using '#align with_top.add_lt_top WithTop.add_lt_topₓ'. -/
 theorem add_lt_top [LT α] {a b : WithTop α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ := by
   simp_rw [WithTop.lt_top_iff_ne_top, add_ne_top]
 #align with_top.add_lt_top WithTop.add_lt_top
@@ -245,12 +209,6 @@ theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ := by
 #align with_top.coe_add_eq_top_iff WithTop.coe_add_eq_top_iff
 -/
 
-/- warning: with_top.covariant_class_add_le -> WithTop.covariantClass_add_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1))) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1183 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1185 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1183 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1185) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1198 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1200 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1198 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1200)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1222 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1224 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1222 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1224) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1237 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1239 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1237 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1239)
-Case conversion may be inaccurate. Consider using '#align with_top.covariant_class_add_le WithTop.covariantClass_add_leₓ'. -/
 instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (· + ·) (· ≤ ·) :=
   ⟨fun a b c h => by
@@ -259,12 +217,6 @@ instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ 
     exact coe_le_coe.2 (add_le_add_left (coe_le_coe.1 h) _)⟩
 #align with_top.covariant_class_add_le WithTop.covariantClass_add_le
 
-/- warning: with_top.covariant_class_swap_add_le -> WithTop.covariantClass_swap_add_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)))) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1378 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1380 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1378 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1380)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1393 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1395 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1393 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1395)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1420 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1422 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1420 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1422)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1435 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1437 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1435 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1437)
-Case conversion may be inaccurate. Consider using '#align with_top.covariant_class_swap_add_le WithTop.covariantClass_swap_add_leₓ'. -/
 instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· ≤ ·) :=
   ⟨fun a b c h => by
@@ -273,12 +225,6 @@ instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·
     exact coe_le_coe.2 (add_le_add_right (coe_le_coe.1 h) _)⟩
 #align with_top.covariant_class_swap_add_le WithTop.covariantClass_swap_add_le
 
-/- warning: with_top.contravariant_class_add_lt -> WithTop.contravariantClass_add_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1573 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1575 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1573 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1575) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1588 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1590 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1588 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1590)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1612 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1614 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1612 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1614) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1627 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1629 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1627 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1629)
-Case conversion may be inaccurate. Consider using '#align with_top.contravariant_class_add_lt WithTop.contravariantClass_add_ltₓ'. -/
 instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithTop α) (WithTop α) (· + ·) (· < ·) :=
   ⟨fun a b c h => by
@@ -289,12 +235,6 @@ instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (
     · exact coe_lt_coe.2 (lt_of_add_lt_add_left <| coe_lt_coe.1 h)⟩
 #align with_top.contravariant_class_add_lt WithTop.contravariantClass_add_lt
 
-/- warning: with_top.contravariant_class_swap_add_lt -> WithTop.contravariantClass_swap_add_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1723 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1725 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1723 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1725)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1738 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1740 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1738 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1740)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1765 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1767 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1765 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1767)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1780 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1782 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1780 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1782)
-Case conversion may be inaccurate. Consider using '#align with_top.contravariant_class_swap_add_lt WithTop.contravariantClass_swap_add_ltₓ'. -/
 instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap (· + ·)) (· < ·)] :
     ContravariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· < ·) :=
   ⟨fun a b c h => by
@@ -304,12 +244,6 @@ instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap
     · exact coe_lt_coe.2 (lt_of_add_lt_add_right <| coe_lt_coe.1 h)⟩
 #align with_top.contravariant_class_swap_add_lt WithTop.contravariantClass_swap_add_lt
 
-/- warning: with_top.le_of_add_le_add_left -> WithTop.le_of_add_le_add_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1943 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1945 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1943 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1945) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1958 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1960 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1958 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1960)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
-Case conversion may be inaccurate. Consider using '#align with_top.le_of_add_le_add_left WithTop.le_of_add_le_add_leftₓ'. -/
 protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤)
     (h : a + b ≤ a + c) : b ≤ c := by
   lift a to α using ha
@@ -319,12 +253,6 @@ protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· +
   exact le_of_add_le_add_left h
 #align with_top.le_of_add_le_add_left WithTop.le_of_add_le_add_left
 
-/- warning: with_top.le_of_add_le_add_right -> WithTop.le_of_add_le_add_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2070 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2072 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2070 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2072)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2085 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2087 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2085 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2087)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
-Case conversion may be inaccurate. Consider using '#align with_top.le_of_add_le_add_right WithTop.le_of_add_le_add_rightₓ'. -/
 protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊤) (h : b + a ≤ c + a) : b ≤ c :=
   by
@@ -336,12 +264,6 @@ protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap
   · exact coe_le_coe.2 (le_of_add_le_add_right <| coe_le_coe.1 h)
 #align with_top.le_of_add_le_add_right WithTop.le_of_add_le_add_right
 
-/- warning: with_top.add_lt_add_left -> WithTop.add_lt_add_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2205 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2207 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2205 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2207) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2220 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2222 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2220 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2222)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
-Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_left WithTop.add_lt_add_leftₓ'. -/
 protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : a + b < a + c := by
   lift a to α using ha
@@ -351,12 +273,6 @@ protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· <
   · exact coe_lt_coe.2 (add_lt_add_left (coe_lt_coe.1 h) _)
 #align with_top.add_lt_add_left WithTop.add_lt_add_left
 
-/- warning: with_top.add_lt_add_right -> WithTop.add_lt_add_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2334 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2336 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2334 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2336)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2349 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2351 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2349 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2351)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
-Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_right WithTop.add_lt_add_rightₓ'. -/
 protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : b + a < c + a := by
   lift a to α using ha
@@ -366,80 +282,38 @@ protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)
   · exact coe_lt_coe.2 (add_lt_add_right (coe_lt_coe.1 h) _)
 #align with_top.add_lt_add_right WithTop.add_lt_add_right
 
-/- warning: with_top.add_le_add_iff_left -> WithTop.add_le_add_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2460 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2462 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2460 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2462) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2475 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2477 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2475 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2477)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2494 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2496 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2494 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2496) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2509 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2511 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2509 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2511)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
-Case conversion may be inaccurate. Consider using '#align with_top.add_le_add_iff_left WithTop.add_le_add_iff_leftₓ'. -/
 protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (· ≤ ·)]
     [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤) : a + b ≤ a + c ↔ b ≤ c :=
   ⟨WithTop.le_of_add_le_add_left ha, fun h => add_le_add_left h a⟩
 #align with_top.add_le_add_iff_left WithTop.add_le_add_iff_left
 
-/- warning: with_top.add_le_add_iff_right -> WithTop.add_le_add_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2585 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2587 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2585 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2587)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2600 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2602 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2600 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2602)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2622 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2624 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2622 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2624)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2637 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2639 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2637 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2639)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
-Case conversion may be inaccurate. Consider using '#align with_top.add_le_add_iff_right WithTop.add_le_add_iff_rightₓ'. -/
 protected theorem add_le_add_iff_right [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
     [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) : b + a ≤ c + a ↔ b ≤ c :=
   ⟨WithTop.le_of_add_le_add_right ha, fun h => add_le_add_right h a⟩
 #align with_top.add_le_add_iff_right WithTop.add_le_add_iff_right
 
-/- warning: with_top.add_lt_add_iff_left -> WithTop.add_lt_add_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2710 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2712 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2710 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2712) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2725 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2727 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2725 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2727)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2744 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2746 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2744 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2746) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2759 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2761 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2759 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2761)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
-Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_iff_left WithTop.add_lt_add_iff_leftₓ'. -/
 protected theorem add_lt_add_iff_left [LT α] [CovariantClass α α (· + ·) (· < ·)]
     [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤) : a + b < a + c ↔ b < c :=
   ⟨lt_of_add_lt_add_left, WithTop.add_lt_add_left ha⟩
 #align with_top.add_lt_add_iff_left WithTop.add_lt_add_iff_left
 
-/- warning: with_top.add_lt_add_iff_right -> WithTop.add_lt_add_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2830 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2832 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2830 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2832)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2845 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2847 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2845 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2847)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2867 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2869 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2867 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2869)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2882 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2884 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2882 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2884)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
-Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_iff_right WithTop.add_lt_add_iff_rightₓ'. -/
 protected theorem add_lt_add_iff_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)]
     [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤) : b + a < c + a ↔ b < c :=
   ⟨lt_of_add_lt_add_right, WithTop.add_lt_add_right ha⟩
 #align with_top.add_lt_add_iff_right WithTop.add_lt_add_iff_right
 
-/- warning: with_top.add_lt_add_of_le_of_lt -> WithTop.add_lt_add_of_le_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toHasLe.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2950 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2952 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2950 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2952) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2965 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2967 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2965 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2967)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2987 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2989 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2987 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2989)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3002 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3004 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3002 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3004)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toLE.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
-Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_of_le_of_lt WithTop.add_lt_add_of_le_of_ltₓ'. -/
 protected theorem add_lt_add_of_le_of_lt [Preorder α] [CovariantClass α α (· + ·) (· < ·)]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) (hab : a ≤ b) (hcd : c < d) :
     a + c < b + d :=
   (WithTop.add_lt_add_left ha hcd).trans_le <| add_le_add_right hab _
 #align with_top.add_lt_add_of_le_of_lt WithTop.add_lt_add_of_le_of_lt
 
-/- warning: with_top.add_lt_add_of_lt_of_le -> WithTop.add_lt_add_of_lt_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithTop.{u1} α) c (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toHasLe.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3078 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3080 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3078 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3080) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3093 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3095 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3093 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3095)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3115 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3117 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3115 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3117)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3130 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3132 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3130 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3132)], (Ne.{succ u1} (WithTop.{u1} α) c (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toLE.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
-Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_of_lt_of_le WithTop.add_lt_add_of_lt_of_leₓ'. -/
 protected theorem add_lt_add_of_lt_of_le [Preorder α] [CovariantClass α α (· + ·) (· ≤ ·)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (hc : c ≠ ⊤) (hab : a < b) (hcd : c ≤ d) :
     a + c < b + d :=
   (WithTop.add_lt_add_right hc hab).trans_le <| add_le_add_left hcd _
 #align with_top.add_lt_add_of_lt_of_le WithTop.add_lt_add_of_lt_of_le
 
-/- warning: with_top.map_add -> WithTop.map_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Add.{u1} α] {F : Type.{u3}} [_inst_2 : Add.{u2} β] [_inst_3 : AddHomClass.{u3, u1, u2} F α β _inst_1 _inst_2] (f : F) (a : WithTop.{u1} α) (b : WithTop.{u1} α), Eq.{succ u2} (WithTop.{u2} β) (WithTop.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b)) (HAdd.hAdd.{u2, u2, u2} (WithTop.{u2} β) (WithTop.{u2} β) (WithTop.{u2} β) (instHAdd.{u2} (WithTop.{u2} β) (WithTop.add.{u2} β _inst_2)) (WithTop.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) a) (WithTop.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Add.{u2} α] {F : Type.{u1}} [_inst_2 : Add.{u3} β] [_inst_3 : AddHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (f : F) (a : WithTop.{u2} α) (b : WithTop.{u2} α), Eq.{succ u3} (WithTop.{u3} β) (WithTop.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) (HAdd.hAdd.{u2, u2, u2} (WithTop.{u2} α) (WithTop.{u2} α) (WithTop.{u2} α) (instHAdd.{u2} (WithTop.{u2} α) (WithTop.add.{u2} α _inst_1)) a b)) (HAdd.hAdd.{u3, u3, u3} (WithTop.{u3} β) (WithTop.{u3} β) (WithTop.{u3} β) (instHAdd.{u3} (WithTop.{u3} β) (WithTop.add.{u3} β _inst_2)) (WithTop.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) a) (WithTop.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) b))
-Case conversion may be inaccurate. Consider using '#align with_top.map_add WithTop.map_addₓ'. -/
 --  There is no `with_top.map_mul_of_mul_hom`, since `with_top` does not have a multiplication.
 @[simp]
 protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : WithTop α) :
@@ -552,23 +426,11 @@ theorem coe_addHom [AddMonoid α] : ⇑(addHom : α →+ WithTop α) = coe :=
   rfl
 #align with_top.coe_coe_add_hom WithTop.coe_addHom
 
-/- warning: with_top.zero_lt_top -> WithTop.zero_lt_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedAddCommMonoid.{u1} α], LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (WithTop.{u1} α) 0 (OfNat.mk.{u1} (WithTop.{u1} α) 0 (Zero.zero.{u1} (WithTop.{u1} α) (WithTop.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1)))))))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : OrderedAddCommMonoid.{u1} α], LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (WithTop.{u1} α) 0 (Zero.toOfNat0.{u1} (WithTop.{u1} α) (WithTop.zero.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1)))))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))
-Case conversion may be inaccurate. Consider using '#align with_top.zero_lt_top WithTop.zero_lt_topₓ'. -/
 @[simp]
 theorem zero_lt_top [OrderedAddCommMonoid α] : (0 : WithTop α) < ⊤ :=
   coe_lt_top 0
 #align with_top.zero_lt_top WithTop.zero_lt_top
 
-/- warning: with_top.zero_lt_coe -> WithTop.zero_lt_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedAddCommMonoid.{u1} α] (a : α), Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (WithTop.{u1} α) 0 (OfNat.mk.{u1} (WithTop.{u1} α) 0 (Zero.zero.{u1} (WithTop.{u1} α) (WithTop.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1)))))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : OrderedAddCommMonoid.{u1} α] (a : α), Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (WithTop.{u1} α) 0 (Zero.toOfNat0.{u1} (WithTop.{u1} α) (WithTop.zero.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1)))))) (WithTop.some.{u1} α a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1))))) a)
-Case conversion may be inaccurate. Consider using '#align with_top.zero_lt_coe WithTop.zero_lt_coeₓ'. -/
 @[simp, norm_cast]
 theorem zero_lt_coe [OrderedAddCommMonoid α] (a : α) : (0 : WithTop α) < a ↔ 0 < a :=
   coe_lt_coe
@@ -674,60 +536,30 @@ theorem unbot_one' [One α] (d : α) : (1 : WithBot α).unbot' d = 1 :=
 #align with_bot.unbot_zero' WithBot.unbot_zero'
 -/
 
-/- warning: with_bot.one_le_coe -> WithBot.one_le_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LE.{u1} α] {a : α}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} (WithBot.{u1} α) 1 (OfNat.mk.{u1} (WithBot.{u1} α) 1 (One.one.{u1} (WithBot.{u1} α) (WithBot.hasOne.{u1} α _inst_1)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LE.{u1} α] {a : α}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_2) (OfNat.ofNat.{u1} (WithBot.{u1} α) 1 (One.toOfNat1.{u1} (WithBot.{u1} α) (WithBot.one.{u1} α _inst_1))) (WithBot.some.{u1} α a)) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align with_bot.one_le_coe WithBot.one_le_coeₓ'. -/
 @[simp, norm_cast, to_additive coe_nonneg]
 theorem one_le_coe [One α] [LE α] {a : α} : 1 ≤ (a : WithBot α) ↔ 1 ≤ a :=
   coe_le_coe
 #align with_bot.one_le_coe WithBot.one_le_coe
 #align with_bot.coe_nonneg WithBot.coe_nonneg
 
-/- warning: with_bot.coe_le_one -> WithBot.coe_le_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LE.{u1} α] {a : α}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_2) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (OfNat.ofNat.{u1} (WithBot.{u1} α) 1 (OfNat.mk.{u1} (WithBot.{u1} α) 1 (One.one.{u1} (WithBot.{u1} α) (WithBot.hasOne.{u1} α _inst_1))))) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LE.{u1} α] {a : α}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_2) (WithBot.some.{u1} α a) (OfNat.ofNat.{u1} (WithBot.{u1} α) 1 (One.toOfNat1.{u1} (WithBot.{u1} α) (WithBot.one.{u1} α _inst_1)))) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align with_bot.coe_le_one WithBot.coe_le_oneₓ'. -/
 @[simp, norm_cast, to_additive coe_le_zero]
 theorem coe_le_one [One α] [LE α] {a : α} : (a : WithBot α) ≤ 1 ↔ a ≤ 1 :=
   coe_le_coe
 #align with_bot.coe_le_one WithBot.coe_le_one
 #align with_bot.coe_le_zero WithBot.coe_le_zero
 
-/- warning: with_bot.one_lt_coe -> WithBot.one_lt_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LT.{u1} α] {a : α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} (WithBot.{u1} α) 1 (OfNat.mk.{u1} (WithBot.{u1} α) 1 (One.one.{u1} (WithBot.{u1} α) (WithBot.hasOne.{u1} α _inst_1)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LT.{u1} α] {a : α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_2) (OfNat.ofNat.{u1} (WithBot.{u1} α) 1 (One.toOfNat1.{u1} (WithBot.{u1} α) (WithBot.one.{u1} α _inst_1))) (WithBot.some.{u1} α a)) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align with_bot.one_lt_coe WithBot.one_lt_coeₓ'. -/
 @[simp, norm_cast, to_additive coe_pos]
 theorem one_lt_coe [One α] [LT α] {a : α} : 1 < (a : WithBot α) ↔ 1 < a :=
   coe_lt_coe
 #align with_bot.one_lt_coe WithBot.one_lt_coe
 #align with_bot.coe_pos WithBot.coe_pos
 
-/- warning: with_bot.coe_lt_one -> WithBot.coe_lt_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LT.{u1} α] {a : α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (OfNat.ofNat.{u1} (WithBot.{u1} α) 1 (OfNat.mk.{u1} (WithBot.{u1} α) 1 (One.one.{u1} (WithBot.{u1} α) (WithBot.hasOne.{u1} α _inst_1))))) (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LT.{u1} α] {a : α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_2) (WithBot.some.{u1} α a) (OfNat.ofNat.{u1} (WithBot.{u1} α) 1 (One.toOfNat1.{u1} (WithBot.{u1} α) (WithBot.one.{u1} α _inst_1)))) (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align with_bot.coe_lt_one WithBot.coe_lt_oneₓ'. -/
 @[simp, norm_cast, to_additive coe_lt_zero]
 theorem coe_lt_one [One α] [LT α] {a : α} : (a : WithBot α) < 1 ↔ a < 1 :=
   coe_lt_coe
 #align with_bot.coe_lt_one WithBot.coe_lt_one
 #align with_bot.coe_lt_zero WithBot.coe_lt_zero
 
-/- warning: with_bot.map_one -> WithBot.map_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : One.{u1} α] (f : α -> β), Eq.{succ u2} (WithBot.{u2} β) (WithBot.map.{u1, u2} α β f (OfNat.ofNat.{u1} (WithBot.{u1} α) 1 (OfNat.mk.{u1} (WithBot.{u1} α) 1 (One.one.{u1} (WithBot.{u1} α) (WithBot.hasOne.{u1} α _inst_1))))) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (WithBot.{u2} β) (HasLiftT.mk.{succ u2, succ u2} β (WithBot.{u2} β) (CoeTCₓ.coe.{succ u2, succ u2} β (WithBot.{u2} β) (WithBot.hasCoeT.{u2} β))) (f (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : One.{u2} α] (f : α -> β), Eq.{succ u1} (WithBot.{u1} β) (WithBot.map.{u2, u1} α β f (OfNat.ofNat.{u2} (WithBot.{u2} α) 1 (One.toOfNat1.{u2} (WithBot.{u2} α) (WithBot.one.{u2} α _inst_1)))) (WithBot.some.{u1} β (f (OfNat.ofNat.{u2} α 1 (One.toOfNat1.{u2} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align with_bot.map_one WithBot.map_oneₓ'. -/
 @[simp, to_additive]
 protected theorem map_one {β} [One α] (f : α → β) : (1 : WithBot α).map f = (f 1 : WithBot β) :=
   rfl
@@ -804,12 +636,6 @@ theorem add_ne_bot : a + b ≠ ⊥ ↔ a ≠ ⊥ ∧ b ≠ ⊥ :=
 #align with_bot.add_ne_bot WithBot.add_ne_bot
 -/
 
-/- warning: with_bot.bot_lt_add -> WithBot.bot_lt_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b)) (And (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) a) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b)) (And (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) a) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) b))
-Case conversion may be inaccurate. Consider using '#align with_bot.bot_lt_add WithBot.bot_lt_addₓ'. -/
 theorem bot_lt_add [LT α] {a b : WithBot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b :=
   @WithTop.add_lt_top αᵒᵈ _ _ _ _
 #align with_bot.bot_lt_add WithBot.bot_lt_add
@@ -834,12 +660,6 @@ theorem coe_add_eq_bot_iff : ↑x + b = ⊥ ↔ b = ⊥ :=
 #align with_bot.coe_add_eq_bot_iff WithBot.coe_add_eq_bot_iff
 -/
 
-/- warning: with_bot.map_add -> WithBot.map_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Add.{u1} α] {F : Type.{u3}} [_inst_2 : Add.{u2} β] [_inst_3 : AddHomClass.{u3, u1, u2} F α β _inst_1 _inst_2] (f : F) (a : WithBot.{u1} α) (b : WithBot.{u1} α), Eq.{succ u2} (WithBot.{u2} β) (WithBot.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b)) (HAdd.hAdd.{u2, u2, u2} (WithBot.{u2} β) (WithBot.{u2} β) (WithBot.{u2} β) (instHAdd.{u2} (WithBot.{u2} β) (WithBot.hasAdd.{u2} β _inst_2)) (WithBot.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) a) (WithBot.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Add.{u2} α] {F : Type.{u1}} [_inst_2 : Add.{u3} β] [_inst_3 : AddHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (f : F) (a : WithBot.{u2} α) (b : WithBot.{u2} α), Eq.{succ u3} (WithBot.{u3} β) (WithBot.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) (HAdd.hAdd.{u2, u2, u2} (WithBot.{u2} α) (WithBot.{u2} α) (WithBot.{u2} α) (instHAdd.{u2} (WithBot.{u2} α) (WithBot.add.{u2} α _inst_1)) a b)) (HAdd.hAdd.{u3, u3, u3} (WithBot.{u3} β) (WithBot.{u3} β) (WithBot.{u3} β) (instHAdd.{u3} (WithBot.{u3} β) (WithBot.add.{u3} β _inst_2)) (WithBot.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) a) (WithBot.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) b))
-Case conversion may be inaccurate. Consider using '#align with_bot.map_add WithBot.map_addₓ'. -/
 --  There is no `with_bot.map_mul_of_mul_hom`, since `with_bot` does not have a multiplication.
 @[simp]
 protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : WithBot α) :
@@ -880,156 +700,72 @@ protected def AddMonoidHom.withBotMap {M N : Type _} [AddZeroClass M] [AddZeroCl
 
 variable [Preorder α]
 
-/- warning: with_bot.covariant_class_add_le -> WithBot.covariantClass_add_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5723 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5725 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5723 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5725) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5738 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5740 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5738 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5740)], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5762 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5764 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5762 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5764) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5777 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5779 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5777 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5779)
-Case conversion may be inaccurate. Consider using '#align with_bot.covariant_class_add_le WithBot.covariantClass_add_leₓ'. -/
 instance covariantClass_add_le [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (· + ·) (· ≤ ·) :=
   @OrderDual.covariantClass_add_le (WithTop αᵒᵈ) _ _ _
 #align with_bot.covariant_class_add_le WithBot.covariantClass_add_le
 
-/- warning: with_bot.covariant_class_swap_add_le -> WithBot.covariantClass_swap_add_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)))) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5827 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5829 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5827 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5829)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5842 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5844 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5842 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5844)], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5869 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5871 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5869 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5871)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5884 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5886 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5884 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5886)
-Case conversion may be inaccurate. Consider using '#align with_bot.covariant_class_swap_add_le WithBot.covariantClass_swap_add_leₓ'. -/
 instance covariantClass_swap_add_le [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· ≤ ·) :=
   @OrderDual.covariantClass_swap_add_le (WithTop αᵒᵈ) _ _ _
 #align with_bot.covariant_class_swap_add_le WithBot.covariantClass_swap_add_le
 
-/- warning: with_bot.contravariant_class_add_lt -> WithBot.contravariantClass_add_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5931 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5933 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5931 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5933) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5946 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5948 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5946 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5948)], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5970 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5972 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5970 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5972) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5985 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5987 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5985 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5987)
-Case conversion may be inaccurate. Consider using '#align with_bot.contravariant_class_add_lt WithBot.contravariantClass_add_ltₓ'. -/
 instance contravariantClass_add_lt [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (· + ·) (· < ·) :=
   @OrderDual.contravariantClass_add_lt (WithTop αᵒᵈ) _ _ _
 #align with_bot.contravariant_class_add_lt WithBot.contravariantClass_add_lt
 
-/- warning: with_bot.contravariant_class_swap_add_lt -> WithBot.contravariantClass_swap_add_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)))) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6035 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6037 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6035 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6037)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6050 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6052 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6050 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6052)], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6077 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6079 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6077 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6079)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6092 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6094 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6092 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6094)
-Case conversion may be inaccurate. Consider using '#align with_bot.contravariant_class_swap_add_lt WithBot.contravariantClass_swap_add_ltₓ'. -/
 instance contravariantClass_swap_add_lt [ContravariantClass α α (swap (· + ·)) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· < ·) :=
   @OrderDual.contravariantClass_swap_add_lt (WithTop αᵒᵈ) _ _ _
 #align with_bot.contravariant_class_swap_add_lt WithBot.contravariantClass_swap_add_lt
 
-/- warning: with_bot.le_of_add_le_add_left -> WithBot.le_of_add_le_add_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6139 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6141 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6139 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6141) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6154 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6156 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6154 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6156)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
-Case conversion may be inaccurate. Consider using '#align with_bot.le_of_add_le_add_left WithBot.le_of_add_le_add_leftₓ'. -/
 protected theorem le_of_add_le_add_left [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥)
     (h : a + b ≤ a + c) : b ≤ c :=
   @WithTop.le_of_add_le_add_left αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.le_of_add_le_add_left WithBot.le_of_add_le_add_left
 
-/- warning: with_bot.le_of_add_le_add_right -> WithBot.le_of_add_le_add_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6227 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6229 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6227 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6229)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6242 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6244 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6242 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6244)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
-Case conversion may be inaccurate. Consider using '#align with_bot.le_of_add_le_add_right WithBot.le_of_add_le_add_rightₓ'. -/
 protected theorem le_of_add_le_add_right [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊥) (h : b + a ≤ c + a) : b ≤ c :=
   @WithTop.le_of_add_le_add_right αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.le_of_add_le_add_right WithBot.le_of_add_le_add_right
 
-/- warning: with_bot.add_lt_add_left -> WithBot.add_lt_add_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6312 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6314 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6312 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6314) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6327 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6329 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6327 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6329)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c))
-Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_left WithBot.add_lt_add_leftₓ'. -/
 protected theorem add_lt_add_left [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) (h : b < c) :
     a + b < a + c :=
   @WithTop.add_lt_add_left αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.add_lt_add_left WithBot.add_lt_add_left
 
-/- warning: with_bot.add_lt_add_right -> WithBot.add_lt_add_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6400 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6402 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6400 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6402)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6415 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6417 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6415 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6417)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a))
-Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_right WithBot.add_lt_add_rightₓ'. -/
 protected theorem add_lt_add_right [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥)
     (h : b < c) : b + a < c + a :=
   @WithTop.add_lt_add_right αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.add_lt_add_right WithBot.add_lt_add_right
 
-/- warning: with_bot.add_le_add_iff_left -> WithBot.add_le_add_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6485 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6487 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6485 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6487) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6500 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6502 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6500 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6502)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6519 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6521 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6519 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6521) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6534 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6536 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6534 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6536)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
-Case conversion may be inaccurate. Consider using '#align with_bot.add_le_add_iff_left WithBot.add_le_add_iff_leftₓ'. -/
 protected theorem add_le_add_iff_left [CovariantClass α α (· + ·) (· ≤ ·)]
     [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥) : a + b ≤ a + c ↔ b ≤ c :=
   ⟨WithBot.le_of_add_le_add_left ha, fun h => add_le_add_left h a⟩
 #align with_bot.add_le_add_iff_left WithBot.add_le_add_iff_left
 
-/- warning: with_bot.add_le_add_iff_right -> WithBot.add_le_add_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6610 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6612 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6610 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6612)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6625 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6627 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6625 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6627)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6647 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6649 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6647 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6649)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6662 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6664 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6662 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6664)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
-Case conversion may be inaccurate. Consider using '#align with_bot.add_le_add_iff_right WithBot.add_le_add_iff_rightₓ'. -/
 protected theorem add_le_add_iff_right [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
     [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊥) : b + a ≤ c + a ↔ b ≤ c :=
   ⟨WithBot.le_of_add_le_add_right ha, fun h => add_le_add_right h a⟩
 #align with_bot.add_le_add_iff_right WithBot.add_le_add_iff_right
 
-/- warning: with_bot.add_lt_add_iff_left -> WithBot.add_lt_add_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6735 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6737 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6735 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6737) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6750 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6752 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6750 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6752)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6769 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6771 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6769 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6771) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6784 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6786 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6784 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6786)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
-Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_iff_left WithBot.add_lt_add_iff_leftₓ'. -/
 protected theorem add_lt_add_iff_left [CovariantClass α α (· + ·) (· < ·)]
     [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) : a + b < a + c ↔ b < c :=
   ⟨lt_of_add_lt_add_left, WithBot.add_lt_add_left ha⟩
 #align with_bot.add_lt_add_iff_left WithBot.add_lt_add_iff_left
 
-/- warning: with_bot.add_lt_add_iff_right -> WithBot.add_lt_add_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6855 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6857 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6855 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6857)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6870 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6872 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6870 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6872)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6892 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6894 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6892 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6894)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6907 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6909 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6907 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6909)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
-Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_iff_right WithBot.add_lt_add_iff_rightₓ'. -/
 protected theorem add_lt_add_iff_right [CovariantClass α α (swap (· + ·)) (· < ·)]
     [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥) : b + a < c + a ↔ b < c :=
   ⟨lt_of_add_lt_add_right, WithBot.add_lt_add_right ha⟩
 #align with_bot.add_lt_add_iff_right WithBot.add_lt_add_iff_right
 
-/- warning: with_bot.add_lt_add_of_le_of_lt -> WithBot.add_lt_add_of_le_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) b (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b d))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6975 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6977 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6975 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6977) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6990 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6992 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6990 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6992)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7012 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7014 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7012 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7014)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7027 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7029 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7027 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7029)], (Ne.{succ u1} (WithBot.{u1} α) b (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b d))
-Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_of_le_of_lt WithBot.add_lt_add_of_le_of_ltₓ'. -/
 protected theorem add_lt_add_of_le_of_lt [CovariantClass α α (· + ·) (· < ·)]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (hb : b ≠ ⊥) (hab : a ≤ b) (hcd : c < d) :
     a + c < b + d :=
   @WithTop.add_lt_add_of_le_of_lt αᵒᵈ _ _ _ _ _ _ _ _ hb hab hcd
 #align with_bot.add_lt_add_of_le_of_lt WithBot.add_lt_add_of_le_of_lt
 
-/- warning: with_bot.add_lt_add_of_lt_of_le -> WithBot.add_lt_add_of_lt_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) d (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b d))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7104 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7106 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7104 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7106) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7119 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7121 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7119 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7121)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7141 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7143 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7141 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7143)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7156 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7158 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7156 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7158)], (Ne.{succ u1} (WithBot.{u1} α) d (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b d))
-Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_of_lt_of_le WithBot.add_lt_add_of_lt_of_leₓ'. -/
 protected theorem add_lt_add_of_lt_of_le [CovariantClass α α (· + ·) (· ≤ ·)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (hd : d ≠ ⊥) (hab : a < b) (hcd : c ≤ d) :
     a + c < b + d :=

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -249,7 +249,7 @@ theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ := by
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1))) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1182 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1184 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1182 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1184) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1197 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1199 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1197 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1199)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1221 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1223 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1221 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1223) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1236 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1238 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1236 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1238)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1183 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1185 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1183 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1185) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1198 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1200 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1198 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1200)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1222 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1224 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1222 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1224) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1237 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1239 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1237 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1239)
 Case conversion may be inaccurate. Consider using '#align with_top.covariant_class_add_le WithTop.covariantClass_add_leₓ'. -/
 instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (· + ·) (· ≤ ·) :=
@@ -263,7 +263,7 @@ instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)))) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1377 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1379 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1377 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1379)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1392 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1394 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1392 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1394)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1419 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1421 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1419 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1421)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1434 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1436 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1434 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1436)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1378 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1380 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1378 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1380)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1393 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1395 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1393 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1395)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1420 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1422 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1420 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1422)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1435 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1437 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1435 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1437)
 Case conversion may be inaccurate. Consider using '#align with_top.covariant_class_swap_add_le WithTop.covariantClass_swap_add_leₓ'. -/
 instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· ≤ ·) :=
@@ -277,7 +277,7 @@ instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1572 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1574 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1572 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1574) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1587 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1589 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1587 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1589)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1611 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1613 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1611 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1613) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1626 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1628 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1626 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1628)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1573 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1575 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1573 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1575) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1588 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1590 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1588 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1590)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1612 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1614 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1612 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1614) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1627 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1629 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1627 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1629)
 Case conversion may be inaccurate. Consider using '#align with_top.contravariant_class_add_lt WithTop.contravariantClass_add_ltₓ'. -/
 instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithTop α) (WithTop α) (· + ·) (· < ·) :=
@@ -293,7 +293,7 @@ instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1722 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1724 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1722 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1724)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1737 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1739 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1737 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1739)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1764 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1766 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1764 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1766)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1779 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1781 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1779 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1781)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1723 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1725 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1723 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1725)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1738 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1740 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1738 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1740)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1765 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1767 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1765 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1767)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1780 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1782 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1780 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1782)
 Case conversion may be inaccurate. Consider using '#align with_top.contravariant_class_swap_add_lt WithTop.contravariantClass_swap_add_ltₓ'. -/
 instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap (· + ·)) (· < ·)] :
     ContravariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· < ·) :=
@@ -308,7 +308,7 @@ instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1942 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1944 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1942 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1944) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1957 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1959 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1957 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1959)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1943 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1945 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1943 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1945) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1958 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1960 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1958 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1960)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
 Case conversion may be inaccurate. Consider using '#align with_top.le_of_add_le_add_left WithTop.le_of_add_le_add_leftₓ'. -/
 protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤)
     (h : a + b ≤ a + c) : b ≤ c := by
@@ -323,7 +323,7 @@ protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· +
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2069 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2071 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2069 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2071)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2084 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2086 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2084 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2086)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2070 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2072 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2070 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2072)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2085 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2087 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2085 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2087)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
 Case conversion may be inaccurate. Consider using '#align with_top.le_of_add_le_add_right WithTop.le_of_add_le_add_rightₓ'. -/
 protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊤) (h : b + a ≤ c + a) : b ≤ c :=
@@ -340,7 +340,7 @@ protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2204 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2206 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2204 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2206) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2219 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2221 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2219 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2221)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2205 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2207 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2205 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2207) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2220 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2222 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2220 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2222)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_left WithTop.add_lt_add_leftₓ'. -/
 protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : a + b < a + c := by
@@ -355,7 +355,7 @@ protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· <
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2333 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2335 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2333 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2335)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2348 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2350 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2348 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2350)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2334 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2336 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2334 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2336)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2349 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2351 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2349 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2351)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_right WithTop.add_lt_add_rightₓ'. -/
 protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : b + a < c + a := by
@@ -370,7 +370,7 @@ protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2459 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2461 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2459 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2461) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2474 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2476 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2474 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2476)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2493 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2495 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2493 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2495) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2508 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2510 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2508 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2510)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2460 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2462 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2460 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2462) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2475 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2477 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2475 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2477)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2494 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2496 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2494 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2496) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2509 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2511 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2509 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2511)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_le_add_iff_left WithTop.add_le_add_iff_leftₓ'. -/
 protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (· ≤ ·)]
     [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤) : a + b ≤ a + c ↔ b ≤ c :=
@@ -381,7 +381,7 @@ protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2584 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2586 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2584 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2586)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2599 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2601 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2599 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2601)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2621 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2623 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2621 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2623)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2636 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2638 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2636 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2638)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2585 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2587 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2585 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2587)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2600 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2602 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2600 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2602)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2622 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2624 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2622 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2624)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2637 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2639 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2637 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2639)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_le_add_iff_right WithTop.add_le_add_iff_rightₓ'. -/
 protected theorem add_le_add_iff_right [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
     [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) : b + a ≤ c + a ↔ b ≤ c :=
@@ -392,7 +392,7 @@ protected theorem add_le_add_iff_right [LE α] [CovariantClass α α (swap (· +
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2709 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2711 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2709 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2711) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2724 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2726 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2724 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2726)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2743 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2745 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2743 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2745) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2758 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2760 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2758 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2760)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2710 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2712 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2710 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2712) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2725 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2727 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2725 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2727)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2744 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2746 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2744 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2746) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2759 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2761 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2759 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2761)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_iff_left WithTop.add_lt_add_iff_leftₓ'. -/
 protected theorem add_lt_add_iff_left [LT α] [CovariantClass α α (· + ·) (· < ·)]
     [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤) : a + b < a + c ↔ b < c :=
@@ -403,7 +403,7 @@ protected theorem add_lt_add_iff_left [LT α] [CovariantClass α α (· + ·) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2829 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2831 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2829 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2831)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2844 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2846 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2844 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2846)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2866 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2868 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2866 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2868)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2881 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2883 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2881 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2883)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2830 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2832 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2830 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2832)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2845 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2847 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2845 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2847)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2867 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2869 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2867 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2869)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2882 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2884 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2882 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2884)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_iff_right WithTop.add_lt_add_iff_rightₓ'. -/
 protected theorem add_lt_add_iff_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)]
     [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤) : b + a < c + a ↔ b < c :=
@@ -414,7 +414,7 @@ protected theorem add_lt_add_iff_right [LT α] [CovariantClass α α (swap (· +
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toHasLe.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2949 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2951 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2949 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2951) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2964 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2966 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2964 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2966)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2986 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2988 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2986 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2988)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3001 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3003 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3001 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3003)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toLE.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2950 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2952 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2950 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2952) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2965 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2967 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2965 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2967)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2987 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2989 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2987 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2989)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3002 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3004 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3002 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3004)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toLE.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_of_le_of_lt WithTop.add_lt_add_of_le_of_ltₓ'. -/
 protected theorem add_lt_add_of_le_of_lt [Preorder α] [CovariantClass α α (· + ·) (· < ·)]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) (hab : a ≤ b) (hcd : c < d) :
@@ -426,7 +426,7 @@ protected theorem add_lt_add_of_le_of_lt [Preorder α] [CovariantClass α α (·
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithTop.{u1} α) c (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toHasLe.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3077 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3079 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3077 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3079) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3092 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3094 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3092 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3094)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3114 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3116 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3114 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3116)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3129 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3131 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3129 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3131)], (Ne.{succ u1} (WithTop.{u1} α) c (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toLE.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3078 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3080 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3078 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3080) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3093 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3095 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3093 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3095)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3115 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3117 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3115 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3117)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3130 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3132 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3130 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3132)], (Ne.{succ u1} (WithTop.{u1} α) c (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toLE.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_of_lt_of_le WithTop.add_lt_add_of_lt_of_leₓ'. -/
 protected theorem add_lt_add_of_lt_of_le [Preorder α] [CovariantClass α α (· + ·) (· ≤ ·)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (hc : c ≠ ⊤) (hab : a < b) (hcd : c ≤ d) :
@@ -884,7 +884,7 @@ variable [Preorder α]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5720 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5722 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5720 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5722) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5735 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5737 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5735 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5737)], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5759 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5761 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5759 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5761) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5774 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5776 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5774 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5776)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5723 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5725 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5723 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5725) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5738 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5740 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5738 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5740)], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5762 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5764 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5762 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5764) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5777 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5779 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5777 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5779)
 Case conversion may be inaccurate. Consider using '#align with_bot.covariant_class_add_le WithBot.covariantClass_add_leₓ'. -/
 instance covariantClass_add_le [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (· + ·) (· ≤ ·) :=
@@ -895,7 +895,7 @@ instance covariantClass_add_le [CovariantClass α α (· + ·) (· ≤ ·)] :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)))) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5824 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5826 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5824 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5826)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5839 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5841 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5839 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5841)], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5866 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5868 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5866 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5868)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5881 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5883 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5881 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5883)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5827 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5829 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5827 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5829)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5842 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5844 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5842 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5844)], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5869 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5871 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5869 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5871)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5884 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5886 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5884 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5886)
 Case conversion may be inaccurate. Consider using '#align with_bot.covariant_class_swap_add_le WithBot.covariantClass_swap_add_leₓ'. -/
 instance covariantClass_swap_add_le [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· ≤ ·) :=
@@ -906,7 +906,7 @@ instance covariantClass_swap_add_le [CovariantClass α α (swap (· + ·)) (· 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5928 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5930 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5928 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5930) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5943 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5945 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5943 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5945)], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5967 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5969 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5967 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5969) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5982 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5984 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5982 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5984)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5931 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5933 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5931 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5933) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5946 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5948 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5946 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5948)], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5970 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5972 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5970 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5972) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5985 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5987 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5985 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5987)
 Case conversion may be inaccurate. Consider using '#align with_bot.contravariant_class_add_lt WithBot.contravariantClass_add_ltₓ'. -/
 instance contravariantClass_add_lt [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (· + ·) (· < ·) :=
@@ -917,7 +917,7 @@ instance contravariantClass_add_lt [ContravariantClass α α (· + ·) (· < ·)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)))) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6032 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6034 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6032 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6034)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6047 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6049 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6047 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6049)], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6074 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6076 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6074 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6076)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6089 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6091 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6089 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6091)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6035 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6037 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6035 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6037)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6050 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6052 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6050 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6052)], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6077 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6079 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6077 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6079)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6092 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6094 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6092 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6094)
 Case conversion may be inaccurate. Consider using '#align with_bot.contravariant_class_swap_add_lt WithBot.contravariantClass_swap_add_ltₓ'. -/
 instance contravariantClass_swap_add_lt [ContravariantClass α α (swap (· + ·)) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· < ·) :=
@@ -928,7 +928,7 @@ instance contravariantClass_swap_add_lt [ContravariantClass α α (swap (· + ·
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6136 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6138 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6136 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6138) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6151 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6153 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6151 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6153)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6139 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6141 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6139 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6141) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6154 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6156 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6154 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6156)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
 Case conversion may be inaccurate. Consider using '#align with_bot.le_of_add_le_add_left WithBot.le_of_add_le_add_leftₓ'. -/
 protected theorem le_of_add_le_add_left [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥)
     (h : a + b ≤ a + c) : b ≤ c :=
@@ -939,7 +939,7 @@ protected theorem le_of_add_le_add_left [ContravariantClass α α (· + ·) (·
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6224 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6226 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6224 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6226)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6239 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6241 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6239 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6241)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6227 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6229 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6227 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6229)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6242 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6244 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6242 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6244)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
 Case conversion may be inaccurate. Consider using '#align with_bot.le_of_add_le_add_right WithBot.le_of_add_le_add_rightₓ'. -/
 protected theorem le_of_add_le_add_right [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊥) (h : b + a ≤ c + a) : b ≤ c :=
@@ -950,7 +950,7 @@ protected theorem le_of_add_le_add_right [ContravariantClass α α (swap (· + 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6309 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6311 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6309 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6311) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6324 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6326 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6324 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6326)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6312 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6314 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6312 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6314) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6327 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6329 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6327 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6329)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c))
 Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_left WithBot.add_lt_add_leftₓ'. -/
 protected theorem add_lt_add_left [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) (h : b < c) :
     a + b < a + c :=
@@ -961,7 +961,7 @@ protected theorem add_lt_add_left [CovariantClass α α (· + ·) (· < ·)] (ha
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6397 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6399 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6397 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6399)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6412 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6414 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6412 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6414)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6400 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6402 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6400 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6402)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6415 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6417 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6415 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6417)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_right WithBot.add_lt_add_rightₓ'. -/
 protected theorem add_lt_add_right [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥)
     (h : b < c) : b + a < c + a :=
@@ -972,7 +972,7 @@ protected theorem add_lt_add_right [CovariantClass α α (swap (· + ·)) (· <
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6482 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6484 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6482 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6484) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6497 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6499 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6497 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6499)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6516 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6518 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6516 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6518) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6531 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6533 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6531 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6533)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6485 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6487 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6485 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6487) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6500 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6502 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6500 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6502)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6519 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6521 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6519 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6521) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6534 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6536 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6534 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6536)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
 Case conversion may be inaccurate. Consider using '#align with_bot.add_le_add_iff_left WithBot.add_le_add_iff_leftₓ'. -/
 protected theorem add_le_add_iff_left [CovariantClass α α (· + ·) (· ≤ ·)]
     [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥) : a + b ≤ a + c ↔ b ≤ c :=
@@ -983,7 +983,7 @@ protected theorem add_le_add_iff_left [CovariantClass α α (· + ·) (· ≤ ·
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6607 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6609 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6607 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6609)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6622 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6624 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6622 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6624)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6644 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6646 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6644 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6646)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6659 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6661 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6659 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6661)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6610 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6612 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6610 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6612)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6625 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6627 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6625 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6627)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6647 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6649 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6647 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6649)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6662 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6664 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6662 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6664)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
 Case conversion may be inaccurate. Consider using '#align with_bot.add_le_add_iff_right WithBot.add_le_add_iff_rightₓ'. -/
 protected theorem add_le_add_iff_right [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
     [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊥) : b + a ≤ c + a ↔ b ≤ c :=
@@ -994,7 +994,7 @@ protected theorem add_le_add_iff_right [CovariantClass α α (swap (· + ·)) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6732 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6734 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6732 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6734) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6747 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6749 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6747 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6749)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6766 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6768 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6766 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6768) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6781 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6783 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6781 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6783)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6735 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6737 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6735 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6737) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6750 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6752 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6750 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6752)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6769 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6771 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6769 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6771) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6784 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6786 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6784 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6786)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
 Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_iff_left WithBot.add_lt_add_iff_leftₓ'. -/
 protected theorem add_lt_add_iff_left [CovariantClass α α (· + ·) (· < ·)]
     [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) : a + b < a + c ↔ b < c :=
@@ -1005,7 +1005,7 @@ protected theorem add_lt_add_iff_left [CovariantClass α α (· + ·) (· < ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6852 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6854 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6852 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6854)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6867 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6869 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6867 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6869)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6889 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6891 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6889 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6891)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6904 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6906 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6904 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6906)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6855 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6857 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6855 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6857)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6870 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6872 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6870 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6872)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6892 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6894 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6892 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6894)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6907 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6909 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6907 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6909)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
 Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_iff_right WithBot.add_lt_add_iff_rightₓ'. -/
 protected theorem add_lt_add_iff_right [CovariantClass α α (swap (· + ·)) (· < ·)]
     [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥) : b + a < c + a ↔ b < c :=
@@ -1016,7 +1016,7 @@ protected theorem add_lt_add_iff_right [CovariantClass α α (swap (· + ·)) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) b (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b d))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6972 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6974 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6972 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6974) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6987 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6989 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6987 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6989)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7009 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7011 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7009 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7011)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7024 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7026 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7024 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7026)], (Ne.{succ u1} (WithBot.{u1} α) b (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b d))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6975 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6977 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6975 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6977) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6990 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6992 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6990 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6992)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7012 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7014 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7012 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7014)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7027 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7029 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7027 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7029)], (Ne.{succ u1} (WithBot.{u1} α) b (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b d))
 Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_of_le_of_lt WithBot.add_lt_add_of_le_of_ltₓ'. -/
 protected theorem add_lt_add_of_le_of_lt [CovariantClass α α (· + ·) (· < ·)]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (hb : b ≠ ⊥) (hab : a ≤ b) (hcd : c < d) :
@@ -1028,7 +1028,7 @@ protected theorem add_lt_add_of_le_of_lt [CovariantClass α α (· + ·) (· < 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) d (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b d))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7101 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7103 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7101 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7103) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7116 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7118 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7116 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7118)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7138 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7140 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7138 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7140)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7153 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7155 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7153 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7155)], (Ne.{succ u1} (WithBot.{u1} α) d (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b d))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7104 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7106 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7104 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7106) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7119 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7121 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7119 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7121)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7141 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7143 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7141 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7143)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7156 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7158 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7156 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7158)], (Ne.{succ u1} (WithBot.{u1} α) d (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b d))
 Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_of_lt_of_le WithBot.add_lt_add_of_lt_of_leₓ'. -/
 protected theorem add_lt_add_of_lt_of_le [CovariantClass α α (· + ·) (· ≤ ·)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (hd : d ≠ ⊥) (hab : a < b) (hcd : c ≤ d) :

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -410,21 +410,29 @@ protected theorem add_lt_add_iff_right [LT α] [CovariantClass α α (swap (· +
   ⟨lt_of_add_lt_add_right, WithTop.add_lt_add_right ha⟩
 #align with_top.add_lt_add_iff_right WithTop.add_lt_add_iff_right
 
-#print WithTop.add_lt_add_of_le_of_lt /-
+/- warning: with_top.add_lt_add_of_le_of_lt -> WithTop.add_lt_add_of_le_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toHasLe.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2949 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2951 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2949 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2951) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2964 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2966 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2964 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2966)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2986 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2988 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2986 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2988)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3001 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3003 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3001 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3003)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toLE.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
+Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_of_le_of_lt WithTop.add_lt_add_of_le_of_ltₓ'. -/
 protected theorem add_lt_add_of_le_of_lt [Preorder α] [CovariantClass α α (· + ·) (· < ·)]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) (hab : a ≤ b) (hcd : c < d) :
     a + c < b + d :=
   (WithTop.add_lt_add_left ha hcd).trans_le <| add_le_add_right hab _
 #align with_top.add_lt_add_of_le_of_lt WithTop.add_lt_add_of_le_of_lt
--/
 
-#print WithTop.add_lt_add_of_lt_of_le /-
+/- warning: with_top.add_lt_add_of_lt_of_le -> WithTop.add_lt_add_of_lt_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithTop.{u1} α) c (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toHasLe.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} {d : WithTop.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3077 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3079 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3077 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3079) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3092 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3094 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3092 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3094)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3114 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3116 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3114 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3116)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3129 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3131 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3129 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.3131)], (Ne.{succ u1} (WithTop.{u1} α) c (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithTop.{u1} α) (Preorder.toLE.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b d))
+Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_of_lt_of_le WithTop.add_lt_add_of_lt_of_leₓ'. -/
 protected theorem add_lt_add_of_lt_of_le [Preorder α] [CovariantClass α α (· + ·) (· ≤ ·)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (hc : c ≠ ⊤) (hab : a < b) (hcd : c ≤ d) :
     a + c < b + d :=
   (WithTop.add_lt_add_right hc hab).trans_le <| add_le_add_left hcd _
 #align with_top.add_lt_add_of_lt_of_le WithTop.add_lt_add_of_lt_of_le
--/
 
 /- warning: with_top.map_add -> WithTop.map_add is a dubious translation:
 lean 3 declaration is
@@ -546,7 +554,7 @@ theorem coe_addHom [AddMonoid α] : ⇑(addHom : α →+ WithTop α) = coe :=
 
 /- warning: with_top.zero_lt_top -> WithTop.zero_lt_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedAddCommMonoid.{u1} α], LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (WithTop.{u1} α) 0 (OfNat.mk.{u1} (WithTop.{u1} α) 0 (Zero.zero.{u1} (WithTop.{u1} α) (WithTop.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1)))))))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))
+  forall {α : Type.{u1}} [_inst_1 : OrderedAddCommMonoid.{u1} α], LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (WithTop.{u1} α) 0 (OfNat.mk.{u1} (WithTop.{u1} α) 0 (Zero.zero.{u1} (WithTop.{u1} α) (WithTop.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1)))))))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : OrderedAddCommMonoid.{u1} α], LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (WithTop.{u1} α) 0 (Zero.toOfNat0.{u1} (WithTop.{u1} α) (WithTop.zero.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1)))))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))
 Case conversion may be inaccurate. Consider using '#align with_top.zero_lt_top WithTop.zero_lt_topₓ'. -/
@@ -557,7 +565,7 @@ theorem zero_lt_top [OrderedAddCommMonoid α] : (0 : WithTop α) < ⊤ :=
 
 /- warning: with_top.zero_lt_coe -> WithTop.zero_lt_coe is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedAddCommMonoid.{u1} α] (a : α), Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (WithTop.{u1} α) 0 (OfNat.mk.{u1} (WithTop.{u1} α) 0 (Zero.zero.{u1} (WithTop.{u1} α) (WithTop.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1)))))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1))))))) a)
+  forall {α : Type.{u1}} [_inst_1 : OrderedAddCommMonoid.{u1} α] (a : α), Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (WithTop.{u1} α) 0 (OfNat.mk.{u1} (WithTop.{u1} α) 0 (Zero.zero.{u1} (WithTop.{u1} α) (WithTop.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1)))))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1))))))) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : OrderedAddCommMonoid.{u1} α] (a : α), Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1)))) (OfNat.ofNat.{u1} (WithTop.{u1} α) 0 (Zero.toOfNat0.{u1} (WithTop.{u1} α) (WithTop.zero.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1)))))) (WithTop.some.{u1} α a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommMonoid.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (AddMonoid.toZero.{u1} α (AddCommMonoid.toAddMonoid.{u1} α (OrderedAddCommMonoid.toAddCommMonoid.{u1} α _inst_1))))) a)
 Case conversion may be inaccurate. Consider using '#align with_top.zero_lt_coe WithTop.zero_lt_coeₓ'. -/
@@ -872,105 +880,161 @@ protected def AddMonoidHom.withBotMap {M N : Type _} [AddZeroClass M] [AddZeroCl
 
 variable [Preorder α]
 
-#print WithBot.covariantClass_add_le /-
+/- warning: with_bot.covariant_class_add_le -> WithBot.covariantClass_add_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5720 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5722 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5720 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5722) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5735 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5737 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5735 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5737)], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5759 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5761 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5759 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5761) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5774 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5776 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5774 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5776)
+Case conversion may be inaccurate. Consider using '#align with_bot.covariant_class_add_le WithBot.covariantClass_add_leₓ'. -/
 instance covariantClass_add_le [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (· + ·) (· ≤ ·) :=
   @OrderDual.covariantClass_add_le (WithTop αᵒᵈ) _ _ _
 #align with_bot.covariant_class_add_le WithBot.covariantClass_add_le
--/
 
-#print WithBot.covariantClass_swap_add_le /-
+/- warning: with_bot.covariant_class_swap_add_le -> WithBot.covariantClass_swap_add_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)))) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5824 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5826 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5824 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5826)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5839 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5841 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5839 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5841)], CovariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5866 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5868 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5866 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5868)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5881 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5883 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5881 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5883)
+Case conversion may be inaccurate. Consider using '#align with_bot.covariant_class_swap_add_le WithBot.covariantClass_swap_add_leₓ'. -/
 instance covariantClass_swap_add_le [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· ≤ ·) :=
   @OrderDual.covariantClass_swap_add_le (WithTop αᵒᵈ) _ _ _
 #align with_bot.covariant_class_swap_add_le WithBot.covariantClass_swap_add_le
--/
 
-#print WithBot.contravariantClass_add_lt /-
+/- warning: with_bot.contravariant_class_add_lt -> WithBot.contravariantClass_add_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1))) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5928 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5930 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5928 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5930) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5943 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5945 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5943 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5945)], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5967 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5969 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5967 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5969) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5982 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5984 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5982 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.5984)
+Case conversion may be inaccurate. Consider using '#align with_bot.contravariant_class_add_lt WithBot.contravariantClass_add_ltₓ'. -/
 instance contravariantClass_add_lt [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (· + ·) (· < ·) :=
   @OrderDual.contravariantClass_add_lt (WithTop αᵒᵈ) _ _ _
 #align with_bot.contravariant_class_add_lt WithBot.contravariantClass_add_lt
--/
 
-#print WithBot.contravariantClass_swap_add_lt /-
+/- warning: with_bot.contravariant_class_swap_add_lt -> WithBot.contravariantClass_swap_add_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)))) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6032 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6034 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6032 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6034)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6047 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6049 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6047 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6049)], ContravariantClass.{u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithBot.{u1} α) (WithBot.{u1} α) (fun (ᾰ : WithBot.{u1} α) (ᾰ : WithBot.{u1} α) => WithBot.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6074 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6076 : WithBot.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6074 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6076)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6089 : WithBot.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6091 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6089 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6091)
+Case conversion may be inaccurate. Consider using '#align with_bot.contravariant_class_swap_add_lt WithBot.contravariantClass_swap_add_ltₓ'. -/
 instance contravariantClass_swap_add_lt [ContravariantClass α α (swap (· + ·)) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· < ·) :=
   @OrderDual.contravariantClass_swap_add_lt (WithTop αᵒᵈ) _ _ _
 #align with_bot.contravariant_class_swap_add_lt WithBot.contravariantClass_swap_add_lt
--/
 
-#print WithBot.le_of_add_le_add_left /-
+/- warning: with_bot.le_of_add_le_add_left -> WithBot.le_of_add_le_add_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6136 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6138 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6136 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6138) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6151 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6153 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6151 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6153)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
+Case conversion may be inaccurate. Consider using '#align with_bot.le_of_add_le_add_left WithBot.le_of_add_le_add_leftₓ'. -/
 protected theorem le_of_add_le_add_left [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥)
     (h : a + b ≤ a + c) : b ≤ c :=
   @WithTop.le_of_add_le_add_left αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.le_of_add_le_add_left WithBot.le_of_add_le_add_left
--/
 
-#print WithBot.le_of_add_le_add_right /-
+/- warning: with_bot.le_of_add_le_add_right -> WithBot.le_of_add_le_add_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6224 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6226 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6224 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6226)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6239 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6241 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6239 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6241)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c)
+Case conversion may be inaccurate. Consider using '#align with_bot.le_of_add_le_add_right WithBot.le_of_add_le_add_rightₓ'. -/
 protected theorem le_of_add_le_add_right [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊥) (h : b + a ≤ c + a) : b ≤ c :=
   @WithTop.le_of_add_le_add_right αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.le_of_add_le_add_right WithBot.le_of_add_le_add_right
--/
 
-#print WithBot.add_lt_add_left /-
+/- warning: with_bot.add_lt_add_left -> WithBot.add_lt_add_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6309 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6311 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6309 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6311) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6324 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6326 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6324 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6326)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c))
+Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_left WithBot.add_lt_add_leftₓ'. -/
 protected theorem add_lt_add_left [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) (h : b < c) :
     a + b < a + c :=
   @WithTop.add_lt_add_left αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.add_lt_add_left WithBot.add_lt_add_left
--/
 
-#print WithBot.add_lt_add_right /-
+/- warning: with_bot.add_lt_add_right -> WithBot.add_lt_add_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6397 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6399 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6397 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6399)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6412 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6414 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6412 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6414)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a))
+Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_right WithBot.add_lt_add_rightₓ'. -/
 protected theorem add_lt_add_right [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥)
     (h : b < c) : b + a < c + a :=
   @WithTop.add_lt_add_right αᵒᵈ _ _ _ _ _ _ ha h
 #align with_bot.add_lt_add_right WithBot.add_lt_add_right
--/
 
-#print WithBot.add_le_add_iff_left /-
+/- warning: with_bot.add_le_add_iff_left -> WithBot.add_le_add_iff_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6482 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6484 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6482 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6484) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6497 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6499 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6497 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6499)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6516 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6518 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6516 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6518) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6531 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6533 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6531 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6533)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+Case conversion may be inaccurate. Consider using '#align with_bot.add_le_add_iff_left WithBot.add_le_add_iff_leftₓ'. -/
 protected theorem add_le_add_iff_left [CovariantClass α α (· + ·) (· ≤ ·)]
     [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥) : a + b ≤ a + c ↔ b ≤ c :=
   ⟨WithBot.le_of_add_le_add_left ha, fun h => add_le_add_left h a⟩
 #align with_bot.add_le_add_iff_left WithBot.add_le_add_iff_left
--/
 
-#print WithBot.add_le_add_iff_right /-
+/- warning: with_bot.add_le_add_iff_right -> WithBot.add_le_add_iff_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6607 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6609 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6607 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6609)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6622 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6624 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6622 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6624)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6644 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6646 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6644 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6646)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6659 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6661 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6659 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6661)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+Case conversion may be inaccurate. Consider using '#align with_bot.add_le_add_iff_right WithBot.add_le_add_iff_rightₓ'. -/
 protected theorem add_le_add_iff_right [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
     [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊥) : b + a ≤ c + a ↔ b ≤ c :=
   ⟨WithBot.le_of_add_le_add_right ha, fun h => add_le_add_right h a⟩
 #align with_bot.add_le_add_iff_right WithBot.add_le_add_iff_right
--/
 
-#print WithBot.add_lt_add_iff_left /-
+/- warning: with_bot.add_lt_add_iff_left -> WithBot.add_lt_add_iff_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6732 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6734 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6732 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6734) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6747 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6749 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6747 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6749)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6766 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6768 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6766 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6768) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6781 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6783 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6781 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6783)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_iff_left WithBot.add_lt_add_iff_leftₓ'. -/
 protected theorem add_lt_add_iff_left [CovariantClass α α (· + ·) (· < ·)]
     [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) : a + b < a + c ↔ b < c :=
   ⟨lt_of_add_lt_add_left, WithBot.add_lt_add_left ha⟩
 #align with_bot.add_lt_add_iff_left WithBot.add_lt_add_iff_left
--/
 
-#print WithBot.add_lt_add_iff_right /-
+/- warning: with_bot.add_lt_add_iff_right -> WithBot.add_lt_add_iff_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6852 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6854 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6852 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6854)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6867 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6869 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6867 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6869)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6889 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6891 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6889 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6891)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6904 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6906 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6904 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6906)], (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) b c))
+Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_iff_right WithBot.add_lt_add_iff_rightₓ'. -/
 protected theorem add_lt_add_iff_right [CovariantClass α α (swap (· + ·)) (· < ·)]
     [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥) : b + a < c + a ↔ b < c :=
   ⟨lt_of_add_lt_add_right, WithBot.add_lt_add_right ha⟩
 #align with_bot.add_lt_add_iff_right WithBot.add_lt_add_iff_right
--/
 
-#print WithBot.add_lt_add_of_le_of_lt /-
+/- warning: with_bot.add_lt_add_of_le_of_lt -> WithBot.add_lt_add_of_le_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) b (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b d))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6972 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6974 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6972 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6974) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6987 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6989 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6987 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.6989)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7009 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7011 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7009 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7011)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7024 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7026 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7024 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7026)], (Ne.{succ u1} (WithBot.{u1} α) b (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b d))
+Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_of_le_of_lt WithBot.add_lt_add_of_le_of_ltₓ'. -/
 protected theorem add_lt_add_of_le_of_lt [CovariantClass α α (· + ·) (· < ·)]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (hb : b ≠ ⊥) (hab : a ≤ b) (hcd : c < d) :
     a + c < b + d :=
   @WithTop.add_lt_add_of_le_of_lt αᵒᵈ _ _ _ _ _ _ _ _ hb hab hcd
 #align with_bot.add_lt_add_of_le_of_lt WithBot.add_lt_add_of_le_of_lt
--/
 
-#print WithBot.add_lt_add_of_lt_of_le /-
+/- warning: with_bot.add_lt_add_of_lt_of_le -> WithBot.add_lt_add_of_lt_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))], (Ne.{succ u1} (WithBot.{u1} α) d (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) b d))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α} {c : WithBot.{u1} α} {d : WithBot.{u1} α} [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7101 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7103 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7101 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7103) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7116 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7118 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7116 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7118)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7138 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7140 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7138 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7140)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7153 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7155 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7153 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.7155)], (Ne.{succ u1} (WithBot.{u1} α) d (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_2)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a c) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) b d))
+Case conversion may be inaccurate. Consider using '#align with_bot.add_lt_add_of_lt_of_le WithBot.add_lt_add_of_lt_of_leₓ'. -/
 protected theorem add_lt_add_of_lt_of_le [CovariantClass α α (· + ·) (· ≤ ·)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (hd : d ≠ ⊥) (hab : a < b) (hcd : c ≤ d) :
     a + c < b + d :=
   @WithTop.add_lt_add_of_lt_of_le αᵒᵈ _ _ _ _ _ _ _ _ hd hab hcd
 #align with_bot.add_lt_add_of_lt_of_le WithBot.add_lt_add_of_lt_of_le
--/
 
 end Add

bump to nightly-2023-05-03-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/36b8aa61ea7c05727161f96a0532897bd72aedab

aa7b8e08

Diff

@@ -249,7 +249,7 @@ theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ := by
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1))) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1184 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1186 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1184 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1186) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1199 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1201 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1199 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1201)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1223 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1225 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1223 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1225) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1238 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1240 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1238 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1240)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1182 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1184 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1182 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1184) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1197 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1199 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1197 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1199)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1221 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1223 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1221 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1223) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1236 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1238 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1236 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1238)
 Case conversion may be inaccurate. Consider using '#align with_top.covariant_class_add_le WithTop.covariantClass_add_leₓ'. -/
 instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (· + ·) (· ≤ ·) :=
@@ -263,7 +263,7 @@ instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)))) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1379 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1381 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1379 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1381)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1394 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1396 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1394 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1396)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1421 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1423 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1421 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1423)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1436 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1438 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1436 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1438)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1377 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1379 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1377 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1379)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1392 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1394 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1392 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1394)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1419 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1421 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1419 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1421)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1434 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1436 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1434 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1436)
 Case conversion may be inaccurate. Consider using '#align with_top.covariant_class_swap_add_le WithTop.covariantClass_swap_add_leₓ'. -/
 instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· ≤ ·) :=
@@ -277,7 +277,7 @@ instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1574 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1576 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1574 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1576) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1589 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1591 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1589 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1591)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1613 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1615 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1613 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1615) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1628 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1630 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1628 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1630)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1572 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1574 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1572 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1574) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1587 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1589 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1587 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1589)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1611 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1613 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1611 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1613) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1626 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1628 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1626 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1628)
 Case conversion may be inaccurate. Consider using '#align with_top.contravariant_class_add_lt WithTop.contravariantClass_add_ltₓ'. -/
 instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithTop α) (WithTop α) (· + ·) (· < ·) :=
@@ -293,7 +293,7 @@ instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1724 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1726 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1724 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1726)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1739 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1741 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1739 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1741)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1766 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1768 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1766 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1768)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1781 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1783 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1781 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1783)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1722 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1724 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1722 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1724)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1737 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1739 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1737 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1739)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1764 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1766 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1764 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1766)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1779 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1781 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1779 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1781)
 Case conversion may be inaccurate. Consider using '#align with_top.contravariant_class_swap_add_lt WithTop.contravariantClass_swap_add_ltₓ'. -/
 instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap (· + ·)) (· < ·)] :
     ContravariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· < ·) :=
@@ -308,7 +308,7 @@ instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1944 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1946 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1944 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1946) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1959 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1961 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1959 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1961)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1942 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1944 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1942 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1944) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1957 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1959 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1957 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1959)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
 Case conversion may be inaccurate. Consider using '#align with_top.le_of_add_le_add_left WithTop.le_of_add_le_add_leftₓ'. -/
 protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤)
     (h : a + b ≤ a + c) : b ≤ c := by
@@ -323,7 +323,7 @@ protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· +
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2071 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2073 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2071 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2073)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2086 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2088 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2086 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2088)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2069 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2071 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2069 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2071)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2084 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2086 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2084 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2086)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
 Case conversion may be inaccurate. Consider using '#align with_top.le_of_add_le_add_right WithTop.le_of_add_le_add_rightₓ'. -/
 protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊤) (h : b + a ≤ c + a) : b ≤ c :=
@@ -340,7 +340,7 @@ protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2206 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2208 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2206 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2208) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2221 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2223 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2221 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2223)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2204 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2206 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2204 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2206) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2219 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2221 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2219 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2221)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_left WithTop.add_lt_add_leftₓ'. -/
 protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : a + b < a + c := by
@@ -355,7 +355,7 @@ protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· <
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2335 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2337 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2335 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2337)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2350 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2352 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2350 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2352)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2333 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2335 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2333 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2335)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2348 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2350 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2348 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2350)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_right WithTop.add_lt_add_rightₓ'. -/
 protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : b + a < c + a := by
@@ -370,7 +370,7 @@ protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2461 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2463 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2461 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2463) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2476 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2478 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2476 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2478)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2495 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2497 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2495 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2497) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2510 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2512 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2510 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2512)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2459 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2461 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2459 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2461) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2474 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2476 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2474 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2476)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2493 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2495 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2493 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2495) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2508 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2510 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2508 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2510)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_le_add_iff_left WithTop.add_le_add_iff_leftₓ'. -/
 protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (· ≤ ·)]
     [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤) : a + b ≤ a + c ↔ b ≤ c :=
@@ -381,7 +381,7 @@ protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2586 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2588 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2586 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2588)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2601 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2603 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2601 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2603)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2623 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2625 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2623 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2625)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2638 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2640 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2638 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2640)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2584 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2586 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2584 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2586)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2599 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2601 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2599 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2601)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2621 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2623 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2621 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2623)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2636 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2638 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2636 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2638)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_le_add_iff_right WithTop.add_le_add_iff_rightₓ'. -/
 protected theorem add_le_add_iff_right [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
     [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) : b + a ≤ c + a ↔ b ≤ c :=
@@ -392,7 +392,7 @@ protected theorem add_le_add_iff_right [LE α] [CovariantClass α α (swap (· +
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2711 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2713 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2711 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2713) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2726 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2728 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2726 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2728)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2745 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2747 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2745 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2747) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2760 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2762 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2760 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2762)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2709 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2711 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2709 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2711) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2724 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2726 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2724 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2726)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2743 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2745 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2743 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2745) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2758 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2760 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2758 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2760)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_iff_left WithTop.add_lt_add_iff_leftₓ'. -/
 protected theorem add_lt_add_iff_left [LT α] [CovariantClass α α (· + ·) (· < ·)]
     [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤) : a + b < a + c ↔ b < c :=
@@ -403,7 +403,7 @@ protected theorem add_lt_add_iff_left [LT α] [CovariantClass α α (· + ·) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2831 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2833 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2831 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2833)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2846 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2848 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2846 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2848)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2868 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2870 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2868 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2870)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2883 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2885 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2883 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2885)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2829 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2831 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2829 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2831)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2844 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2846 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2844 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2846)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2866 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2868 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2866 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2868)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2881 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2883 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2881 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2883)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_iff_right WithTop.add_lt_add_iff_rightₓ'. -/
 protected theorem add_lt_add_iff_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)]
     [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤) : b + a < c + a ↔ b < c :=

bump to nightly-2023-03-18-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/02ba8949f486ebecf93fe7460f1ed0564b5e442c

73d15350

Diff

@@ -52,17 +52,21 @@ theorem coe_eq_one {a : α} : (a : WithTop α) = 1 ↔ a = 1 :=
 #align with_top.coe_eq_zero WithTop.coe_eq_zero
 -/
 
+#print WithTop.untop_one /-
 @[simp, to_additive]
 theorem untop_one : (1 : WithTop α).untop coe_ne_top = 1 :=
   rfl
 #align with_top.untop_one WithTop.untop_one
 #align with_top.untop_zero WithTop.untop_zero
+-/
 
+#print WithTop.untop_one' /-
 @[simp, to_additive]
 theorem untop_one' (d : α) : (1 : WithTop α).untop' d = 1 :=
   rfl
 #align with_top.untop_one' WithTop.untop_one'
 #align with_top.untop_zero' WithTop.untop_zero'
+-/
 
 /- warning: with_top.one_le_coe -> WithTop.one_le_coe is a dubious translation:
 lean 3 declaration is
@@ -245,7 +249,7 @@ theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ := by
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1))) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1143 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1145 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1143 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1145) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1158 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1160 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1158 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1160)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1182 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1184 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1182 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1184) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1197 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1199 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1197 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1199)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1184 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1186 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1184 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1186) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1199 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1201 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1199 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1201)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1223 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1225 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1223 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1225) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1238 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1240 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1238 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1240)
 Case conversion may be inaccurate. Consider using '#align with_top.covariant_class_add_le WithTop.covariantClass_add_leₓ'. -/
 instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (· + ·) (· ≤ ·) :=
@@ -259,7 +263,7 @@ instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)))) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1338 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1340 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1338 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1340)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1353 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1355 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1353 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1355)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1380 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1382 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1380 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1382)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1395 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1397 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1395 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1397)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1379 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1381 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1379 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1381)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1394 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1396 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1394 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1396)], CovariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1421 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1423 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1421 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1423)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1436 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1438 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1436 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1438)
 Case conversion may be inaccurate. Consider using '#align with_top.covariant_class_swap_add_le WithTop.covariantClass_swap_add_leₓ'. -/
 instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· ≤ ·) :=
@@ -273,7 +277,7 @@ instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1533 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1535 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1533 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1535) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1548 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1550 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1548 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1550)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1572 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1574 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1572 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1574) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1587 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1589 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1587 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1589)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1574 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1576 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1574 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1576) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1589 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1591 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1589 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1591)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1613 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1615 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1613 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1615) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1628 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1630 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1628 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1630)
 Case conversion may be inaccurate. Consider using '#align with_top.contravariant_class_add_lt WithTop.contravariantClass_add_ltₓ'. -/
 instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithTop α) (WithTop α) (· + ·) (· < ·) :=
@@ -289,7 +293,7 @@ instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1683 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1685 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1683 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1685)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1698 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1700 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1698 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1700)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1725 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1727 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1725 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1727)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1740 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1742 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1740 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1742)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1724 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1726 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1724 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1726)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1739 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1741 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1739 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1741)], ContravariantClass.{u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (Function.swap.{succ u1, succ u1, succ u1} (WithTop.{u1} α) (WithTop.{u1} α) (fun (ᾰ : WithTop.{u1} α) (ᾰ : WithTop.{u1} α) => WithTop.{u1} α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1766 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1768 : WithTop.{u1} α) => HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1766 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1768)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1781 : WithTop.{u1} α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1783 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1781 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1783)
 Case conversion may be inaccurate. Consider using '#align with_top.contravariant_class_swap_add_lt WithTop.contravariantClass_swap_add_ltₓ'. -/
 instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap (· + ·)) (· < ·)] :
     ContravariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· < ·) :=
@@ -304,7 +308,7 @@ instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1903 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1905 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1903 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1905) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1918 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1920 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1918 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1920)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1944 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1946 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1944 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1946) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1959 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1961 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1959 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.1961)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
 Case conversion may be inaccurate. Consider using '#align with_top.le_of_add_le_add_left WithTop.le_of_add_le_add_leftₓ'. -/
 protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤)
     (h : a + b ≤ a + c) : b ≤ c := by
@@ -319,7 +323,7 @@ protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· +
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2030 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2032 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2030 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2032)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2045 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2047 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2045 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2047)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2071 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2073 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2071 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2073)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2086 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2088 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2086 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2088)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) -> (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c)
 Case conversion may be inaccurate. Consider using '#align with_top.le_of_add_le_add_right WithTop.le_of_add_le_add_rightₓ'. -/
 protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊤) (h : b + a ≤ c + a) : b ≤ c :=
@@ -336,7 +340,7 @@ protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2165 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2167 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2165 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2167) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2180 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2182 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2180 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2182)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2206 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2208 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2206 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2208) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2221 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2223 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2221 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2223)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_left WithTop.add_lt_add_leftₓ'. -/
 protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : a + b < a + c := by
@@ -351,7 +355,7 @@ protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· <
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2294 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2296 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2294 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2296)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2309 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2311 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2309 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2311)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2335 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2337 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2335 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2337)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2350 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2352 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2350 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2352)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_right WithTop.add_lt_add_rightₓ'. -/
 protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : b + a < c + a := by
@@ -366,7 +370,7 @@ protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2420 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2422 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2420 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2422) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2435 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2437 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2435 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2437)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2454 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2456 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2454 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2456) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2469 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2471 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2469 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2471)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2461 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2463 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2461 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2463) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2476 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2478 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2476 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2478)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2495 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2497 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2495 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2497) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2510 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2512 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2510 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2512)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_le_add_iff_left WithTop.add_le_add_iff_leftₓ'. -/
 protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (· ≤ ·)]
     [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤) : a + b ≤ a + c ↔ b ≤ c :=
@@ -377,7 +381,7 @@ protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LE.le.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2545 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2547 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2545 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2547)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2560 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2562 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2560 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2562)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2582 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2584 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2582 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2584)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2597 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2599 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2597 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2599)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2586 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2588 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2586 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2588)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2601 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2603 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2601 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2603)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2623 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2625 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2623 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2625)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2638 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2640 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2638 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2640)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_le_add_iff_right WithTop.add_le_add_iff_rightₓ'. -/
 protected theorem add_le_add_iff_right [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
     [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) : b + a ≤ c + a ↔ b ≤ c :=
@@ -388,7 +392,7 @@ protected theorem add_le_add_iff_right [LE α] [CovariantClass α α (swap (· +
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1)) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2670 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2672 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2670 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2672) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2685 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2687 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2685 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2687)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2704 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2706 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2704 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2706) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2719 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2721 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2719 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2721)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2711 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2713 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2711 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2713) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2726 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2728 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2726 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2728)] [_inst_4 : ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2745 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2747 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2745 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2747) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2760 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2762 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2760 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2762)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a c)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_iff_left WithTop.add_lt_add_iff_leftₓ'. -/
 protected theorem add_lt_add_iff_left [LT α] [CovariantClass α α (· + ·) (· < ·)]
     [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤) : a + b < a + c ↔ b < c :=
@@ -399,7 +403,7 @@ protected theorem add_lt_add_iff_left [LT α] [CovariantClass α α (· + ·) (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1))) (LT.lt.{u1} α _inst_2)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2790 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2792 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2790 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2792)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2805 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2807 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2805 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2807)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2827 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2829 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2827 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2829)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2842 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2844 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2842 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2844)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α} {c : WithTop.{u1} α} [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2831 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2833 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2831 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2833)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2846 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2848 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2846 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2848)] [_inst_4 : ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2868 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2870 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α _inst_1) x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2868 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2870)) (fun (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2883 : α) (x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2885 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2883 x._@.Mathlib.Algebra.Order.Monoid.WithTop._hyg.2885)], (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) b a) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) c a)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b c))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_add_iff_right WithTop.add_lt_add_iff_rightₓ'. -/
 protected theorem add_lt_add_iff_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)]
     [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤) : b + a < c + a ↔ b < c :=
@@ -646,17 +650,21 @@ theorem coe_eq_one [One α] {a : α} : (a : WithBot α) = 1 ↔ a = 1 :=
 #align with_bot.coe_eq_zero WithBot.coe_eq_zero
 -/
 
+#print WithBot.unbot_one /-
 @[simp, to_additive]
 theorem unbot_one [One α] : (1 : WithBot α).unbot coe_ne_bot = 1 :=
   rfl
 #align with_bot.unbot_one WithBot.unbot_one
 #align with_bot.unbot_zero WithBot.unbot_zero
+-/
 
+#print WithBot.unbot_one' /-
 @[simp, to_additive]
 theorem unbot_one' [One α] (d : α) : (1 : WithBot α).unbot' d = 1 :=
   rfl
 #align with_bot.unbot_one' WithBot.unbot_one'
 #align with_bot.unbot_zero' WithBot.unbot_zero'
+-/
 
 /- warning: with_bot.one_le_coe -> WithBot.one_le_coe is a dubious translation:
 lean 3 declaration is

bump to nightly-2023-03-16-03

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

8ae28b0b

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 
 ! This file was ported from Lean 3 source module algebra.order.monoid.with_top
-! leanprover-community/mathlib commit afdb4fa3b32d41106a4a09b371ce549ad7958abd
+! leanprover-community/mathlib commit 0111834459f5d7400215223ea95ae38a1265a907
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,7 +16,8 @@ import Mathbin.Data.Nat.Cast.Defs
 /-! # Adjoining top/bottom elements to ordered monoids.
 
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
-> Any changes to this file require a corresponding PR to mathlib4.-/
+> Any changes to this file require a corresponding PR to mathlib4.
+-/
 
 
 universe u v
@@ -51,6 +52,18 @@ theorem coe_eq_one {a : α} : (a : WithTop α) = 1 ↔ a = 1 :=
 #align with_top.coe_eq_zero WithTop.coe_eq_zero
 -/
 
+@[simp, to_additive]
+theorem untop_one : (1 : WithTop α).untop coe_ne_top = 1 :=
+  rfl
+#align with_top.untop_one WithTop.untop_one
+#align with_top.untop_zero WithTop.untop_zero
+
+@[simp, to_additive]
+theorem untop_one' (d : α) : (1 : WithTop α).untop' d = 1 :=
+  rfl
+#align with_top.untop_one' WithTop.untop_one'
+#align with_top.untop_zero' WithTop.untop_zero'
+
 /- warning: with_top.one_le_coe -> WithTop.one_le_coe is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LE.{u1} α] {a : α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} (WithTop.{u1} α) 1 (OfNat.mk.{u1} (WithTop.{u1} α) 1 (One.one.{u1} (WithTop.{u1} α) (WithTop.one.{u1} α _inst_1)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))) a)
@@ -633,6 +646,18 @@ theorem coe_eq_one [One α] {a : α} : (a : WithBot α) = 1 ↔ a = 1 :=
 #align with_bot.coe_eq_zero WithBot.coe_eq_zero
 -/
 
+@[simp, to_additive]
+theorem unbot_one [One α] : (1 : WithBot α).unbot coe_ne_bot = 1 :=
+  rfl
+#align with_bot.unbot_one WithBot.unbot_one
+#align with_bot.unbot_zero WithBot.unbot_zero
+
+@[simp, to_additive]
+theorem unbot_one' [One α] (d : α) : (1 : WithBot α).unbot' d = 1 :=
+  rfl
+#align with_bot.unbot_one' WithBot.unbot_one'
+#align with_bot.unbot_zero' WithBot.unbot_zero'
+
 /- warning: with_bot.one_le_coe -> WithBot.one_le_coe is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : One.{u1} α] [_inst_2 : LE.{u1} α] {a : α}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} (WithBot.{u1} α) 1 (OfNat.mk.{u1} (WithBot.{u1} α) 1 (One.one.{u1} (WithBot.{u1} α) (WithBot.hasOne.{u1} α _inst_1)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α _inst_1))) a)

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -413,7 +413,7 @@ protected theorem add_lt_add_of_lt_of_le [Preorder α] [CovariantClass α α (·
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Add.{u1} α] {F : Type.{u3}} [_inst_2 : Add.{u2} β] [_inst_3 : AddHomClass.{u3, u1, u2} F α β _inst_1 _inst_2] (f : F) (a : WithTop.{u1} α) (b : WithTop.{u1} α), Eq.{succ u2} (WithTop.{u2} β) (WithTop.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b)) (HAdd.hAdd.{u2, u2, u2} (WithTop.{u2} β) (WithTop.{u2} β) (WithTop.{u2} β) (instHAdd.{u2} (WithTop.{u2} β) (WithTop.add.{u2} β _inst_2)) (WithTop.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) a) (WithTop.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) b))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Add.{u2} α] {F : Type.{u1}} [_inst_2 : Add.{u3} β] [_inst_3 : AddHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (f : F) (a : WithTop.{u2} α) (b : WithTop.{u2} α), Eq.{succ u3} (WithTop.{u3} β) (WithTop.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) (HAdd.hAdd.{u2, u2, u2} (WithTop.{u2} α) (WithTop.{u2} α) (WithTop.{u2} α) (instHAdd.{u2} (WithTop.{u2} α) (WithTop.add.{u2} α _inst_1)) a b)) (HAdd.hAdd.{u3, u3, u3} (WithTop.{u3} β) (WithTop.{u3} β) (WithTop.{u3} β) (instHAdd.{u3} (WithTop.{u3} β) (WithTop.add.{u3} β _inst_2)) (WithTop.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) a) (WithTop.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) b))
+  forall {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Add.{u2} α] {F : Type.{u1}} [_inst_2 : Add.{u3} β] [_inst_3 : AddHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (f : F) (a : WithTop.{u2} α) (b : WithTop.{u2} α), Eq.{succ u3} (WithTop.{u3} β) (WithTop.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) (HAdd.hAdd.{u2, u2, u2} (WithTop.{u2} α) (WithTop.{u2} α) (WithTop.{u2} α) (instHAdd.{u2} (WithTop.{u2} α) (WithTop.add.{u2} α _inst_1)) a b)) (HAdd.hAdd.{u3, u3, u3} (WithTop.{u3} β) (WithTop.{u3} β) (WithTop.{u3} β) (instHAdd.{u3} (WithTop.{u3} β) (WithTop.add.{u3} β _inst_2)) (WithTop.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) a) (WithTop.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) b))
 Case conversion may be inaccurate. Consider using '#align with_top.map_add WithTop.map_addₓ'. -/
 --  There is no `with_top.map_mul_of_mul_hom`, since `with_top` does not have a multiplication.
 @[simp]
@@ -797,7 +797,7 @@ theorem coe_add_eq_bot_iff : ↑x + b = ⊥ ↔ b = ⊥ :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Add.{u1} α] {F : Type.{u3}} [_inst_2 : Add.{u2} β] [_inst_3 : AddHomClass.{u3, u1, u2} F α β _inst_1 _inst_2] (f : F) (a : WithBot.{u1} α) (b : WithBot.{u1} α), Eq.{succ u2} (WithBot.{u2} β) (WithBot.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b)) (HAdd.hAdd.{u2, u2, u2} (WithBot.{u2} β) (WithBot.{u2} β) (WithBot.{u2} β) (instHAdd.{u2} (WithBot.{u2} β) (WithBot.hasAdd.{u2} β _inst_2)) (WithBot.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) a) (WithBot.map.{u1, u2} α β (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => α -> β) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F α (fun (_x : α) => β) (AddHomClass.toFunLike.{u3, u1, u2} F α β _inst_1 _inst_2 _inst_3)) f) b))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Add.{u2} α] {F : Type.{u1}} [_inst_2 : Add.{u3} β] [_inst_3 : AddHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (f : F) (a : WithBot.{u2} α) (b : WithBot.{u2} α), Eq.{succ u3} (WithBot.{u3} β) (WithBot.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) (HAdd.hAdd.{u2, u2, u2} (WithBot.{u2} α) (WithBot.{u2} α) (WithBot.{u2} α) (instHAdd.{u2} (WithBot.{u2} α) (WithBot.add.{u2} α _inst_1)) a b)) (HAdd.hAdd.{u3, u3, u3} (WithBot.{u3} β) (WithBot.{u3} β) (WithBot.{u3} β) (instHAdd.{u3} (WithBot.{u3} β) (WithBot.add.{u3} β _inst_2)) (WithBot.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) a) (WithBot.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.398 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) b))
+  forall {α : Type.{u2}} {β : Type.{u3}} [_inst_1 : Add.{u2} α] {F : Type.{u1}} [_inst_2 : Add.{u3} β] [_inst_3 : AddHomClass.{u1, u2, u3} F α β _inst_1 _inst_2] (f : F) (a : WithBot.{u2} α) (b : WithBot.{u2} α), Eq.{succ u3} (WithBot.{u3} β) (WithBot.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) (HAdd.hAdd.{u2, u2, u2} (WithBot.{u2} α) (WithBot.{u2} α) (WithBot.{u2} α) (instHAdd.{u2} (WithBot.{u2} α) (WithBot.add.{u2} α _inst_1)) a b)) (HAdd.hAdd.{u3, u3, u3} (WithBot.{u3} β) (WithBot.{u3} β) (WithBot.{u3} β) (instHAdd.{u3} (WithBot.{u3} β) (WithBot.add.{u3} β _inst_2)) (WithBot.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) a) (WithBot.map.{u2, u3} α β (FunLike.coe.{succ u1, succ u2, succ u3} F α (fun (_x : α) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.403 : α) => β) _x) (AddHomClass.toFunLike.{u1, u2, u3} F α β _inst_1 _inst_2 _inst_3) f) b))
 Case conversion may be inaccurate. Consider using '#align with_bot.map_add WithBot.map_addₓ'. -/
 --  There is no `with_bot.map_mul_of_mul_hom`, since `with_bot` does not have a multiplication.
 @[simp]

bump to nightly-2023-02-25-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/271bf175e6c51b8d31d6c0107b7bb4a967c7277e

2eb4cae7

Diff

@@ -198,7 +198,7 @@ theorem add_ne_top : a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (And (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : PartialOrder.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (And (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) b (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (And (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_2) b (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))))
 Case conversion may be inaccurate. Consider using '#align with_top.add_lt_top WithTop.add_lt_topₓ'. -/
 theorem add_lt_top [LT α] {a b : WithTop α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ := by
   simp_rw [WithTop.lt_top_iff_ne_top, add_ne_top]
@@ -767,7 +767,7 @@ theorem add_ne_bot : a + b ≠ ⊥ ↔ a ≠ ⊥ ∧ b ≠ ⊥ :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b)) (And (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) a) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) b))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : PartialOrder.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b)) (And (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) a) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) b))
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b)) (And (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) a) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) b))
 Case conversion may be inaccurate. Consider using '#align with_bot.bot_lt_add WithBot.bot_lt_addₓ'. -/
 theorem bot_lt_add [LT α] {a b : WithBot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b :=
   @WithTop.add_lt_top αᵒᵈ _ _ _ _

bump to nightly-2023-02-25-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/271bf175e6c51b8d31d6c0107b7bb4a967c7277e

39ef98db

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 
 ! This file was ported from Lean 3 source module algebra.order.monoid.with_top
-! leanprover-community/mathlib commit e7e2ba8aa216a5833b5ed85a93317263711a36b5
+! leanprover-community/mathlib commit afdb4fa3b32d41106a4a09b371ce549ad7958abd
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -194,11 +194,15 @@ theorem add_ne_top : a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ :=
 #align with_top.add_ne_top WithTop.add_ne_top
 -/
 
-#print WithTop.add_lt_top /-
-theorem add_lt_top [PartialOrder α] {a b : WithTop α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ := by
-  simp_rw [lt_top_iff_ne_top, add_ne_top]
+/- warning: with_top.add_lt_top -> WithTop.add_lt_top is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (And (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_2) b (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : PartialOrder.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) (HAdd.hAdd.{u1, u1, u1} (WithTop.{u1} α) (WithTop.{u1} α) (WithTop.{u1} α) (instHAdd.{u1} (WithTop.{u1} α) (WithTop.add.{u1} α _inst_1)) a b) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (And (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) b (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))))
+Case conversion may be inaccurate. Consider using '#align with_top.add_lt_top WithTop.add_lt_topₓ'. -/
+theorem add_lt_top [LT α] {a b : WithTop α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ := by
+  simp_rw [WithTop.lt_top_iff_ne_top, add_ne_top]
 #align with_top.add_lt_top WithTop.add_lt_top
--/
 
 #print WithTop.add_eq_coe /-
 theorem add_eq_coe :
@@ -759,11 +763,15 @@ theorem add_ne_bot : a + b ≠ ⊥ ↔ a ≠ ⊥ ∧ b ≠ ⊥ :=
 #align with_bot.add_ne_bot WithBot.add_ne_bot
 -/
 
-#print WithBot.bot_lt_add /-
-theorem bot_lt_add [PartialOrder α] {a b : WithBot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b :=
+/- warning: with_bot.bot_lt_add -> WithBot.bot_lt_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.hasAdd.{u1} α _inst_1)) a b)) (And (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) a) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_2) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Add.{u1} α] [_inst_2 : PartialOrder.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) (HAdd.hAdd.{u1, u1, u1} (WithBot.{u1} α) (WithBot.{u1} α) (WithBot.{u1} α) (instHAdd.{u1} (WithBot.{u1} α) (WithBot.add.{u1} α _inst_1)) a b)) (And (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) a) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) b))
+Case conversion may be inaccurate. Consider using '#align with_bot.bot_lt_add WithBot.bot_lt_addₓ'. -/
+theorem bot_lt_add [LT α] {a b : WithBot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b :=
   @WithTop.add_lt_top αᵒᵈ _ _ _ _
 #align with_bot.bot_lt_add WithBot.bot_lt_add
--/
 
 #print WithBot.add_eq_coe /-
 theorem add_eq_coe : a + b = x ↔ ∃ a' b' : α, ↑a' = a ∧ ↑b' = b ∧ a' + b' = x :=

e7e2ba8a

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: superfluous parentheses part 2 (#12131)

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

d48d30ac

Diff

@@ -175,7 +175,7 @@ theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ := by s
 
 theorem add_right_cancel_iff [IsRightCancelAdd α] (ha : a ≠ ⊤) : b + a = c + a ↔ b = c := by
   lift a to α using ha
-  obtain rfl | hb := (eq_or_ne b ⊤)
+  obtain rfl | hb := eq_or_ne b ⊤
   · rw [top_add, eq_comm, WithTop.add_coe_eq_top_iff, eq_comm]
   lift b to α using hb
   simp_rw [← WithTop.coe_add, eq_comm, WithTop.add_eq_coe, coe_eq_coe, exists_and_left,
@@ -186,7 +186,7 @@ theorem add_right_cancel [IsRightCancelAdd α] (ha : a ≠ ⊤) (h : b + a = c +
 
 theorem add_left_cancel_iff [IsLeftCancelAdd α] (ha : a ≠ ⊤) : a + b = a + c ↔ b = c := by
   lift a to α using ha
-  obtain rfl | hb := (eq_or_ne b ⊤)
+  obtain rfl | hb := eq_or_ne b ⊤
   · rw [add_top, eq_comm, WithTop.coe_add_eq_top_iff, eq_comm]
   lift b to α using hb
   simp_rw [← WithTop.coe_add, eq_comm, WithTop.add_eq_coe, eq_comm, coe_eq_coe,

chore: Rename coe_nat/coe_int/coe_rat to natCast/intCast/ratCast (#11499)

This is less exhaustive than its sibling #11486 because edge cases are harder to classify. No fundamental difficulty, just me being a bit fast and lazy.

Reduce the diff of #11203

b2af0d13

Diff

@@ -373,14 +373,19 @@ instance addMonoidWithOne : AddMonoidWithOne (WithTop α) :=
       simp only -- Porting note: Had to add this...?
       rw [Nat.cast_add_one, WithTop.coe_add, WithTop.coe_one] }
 
-@[simp, norm_cast] lemma coe_nat (n : ℕ) : ((n : α) : WithTop α) = n := rfl
-#align with_top.coe_nat WithTop.coe_nat
+@[simp, norm_cast] lemma coe_natCast (n : ℕ) : ((n : α) : WithTop α) = n := rfl
+#align with_top.coe_nat WithTop.coe_natCast
 
-@[simp] lemma nat_ne_top (n : ℕ) : (n : WithTop α) ≠ ⊤ := coe_ne_top
-#align with_top.nat_ne_top WithTop.nat_ne_top
+@[simp] lemma natCast_ne_top (n : ℕ) : (n : WithTop α) ≠ ⊤ := coe_ne_top
+#align with_top.nat_ne_top WithTop.natCast_ne_top
 
-@[simp] lemma top_ne_nat (n : ℕ) : (⊤ : WithTop α) ≠ n := top_ne_coe
-#align with_top.top_ne_nat WithTop.top_ne_nat
+@[simp] lemma top_ne_natCast (n : ℕ) : (⊤ : WithTop α) ≠ n := top_ne_coe
+#align with_top.top_ne_nat WithTop.top_ne_natCast
+
+-- 2024-04-05
+@[deprecated] alias coe_nat := coe_natCast
+@[deprecated] alias nat_ne_top := natCast_ne_top
+@[deprecated] alias top_ne_nat := top_ne_natCast
 
 end AddMonoidWithOne
 
@@ -569,14 +574,19 @@ variable [AddMonoidWithOne α]
 
 instance addMonoidWithOne : AddMonoidWithOne (WithBot α) := WithTop.addMonoidWithOne
 
-@[norm_cast] lemma coe_nat (n : ℕ) : ((n : α) : WithBot α) = n := rfl
-#align with_bot.coe_nat WithBot.coe_nat
+@[norm_cast] lemma coe_natCast (n : ℕ) : ((n : α) : WithBot α) = n := rfl
+#align with_bot.coe_nat WithBot.coe_natCast
+
+@[simp] lemma natCast_ne_bot (n : ℕ) : (n : WithBot α) ≠ ⊥ := coe_ne_bot
+#align with_bot.nat_ne_bot WithBot.natCast_ne_bot
 
-@[simp] lemma nat_ne_bot (n : ℕ) : (n : WithBot α) ≠ ⊥ := coe_ne_bot
-#align with_bot.nat_ne_bot WithBot.nat_ne_bot
+@[simp] lemma bot_ne_natCast (n : ℕ) : (⊥ : WithBot α) ≠ n := bot_ne_coe
+#align with_bot.bot_ne_nat WithBot.bot_ne_natCast
 
-@[simp] lemma bot_ne_nat (n : ℕ) : (⊥ : WithBot α) ≠ n := bot_ne_coe
-#align with_bot.bot_ne_nat WithBot.bot_ne_nat
+-- 2024-04-05
+@[deprecated] alias coe_nat := coe_natCast
+@[deprecated] alias nat_ne_bot := natCast_ne_bot
+@[deprecated] alias bot_ne_nat := bot_ne_natCast
 
 end AddMonoidWithOne

style: remove redundant instance arguments (#11581)

I removed some redundant instance arguments throughout Mathlib. To do this, I used VS Code's regex search. See https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/repeating.20instances.20from.20variable.20command I closed the previous PR for this and reopened it.

acda20c6

Diff

@@ -487,7 +487,7 @@ lemma one_eq_coe : 1 = (a : WithBot α) ↔ a = 1 := eq_comm.trans coe_eq_one
 @[to_additive (attr := simp)] lemma one_ne_bot : (1 : WithBot α) ≠ ⊥ := coe_ne_bot
 
 @[to_additive (attr := simp)]
-theorem unbot_one [One α] : (1 : WithBot α).unbot coe_ne_bot = 1 :=
+theorem unbot_one : (1 : WithBot α).unbot coe_ne_bot = 1 :=
   rfl
 #align with_bot.unbot_one WithBot.unbot_one
 #align with_bot.unbot_zero WithBot.unbot_zero

chore: classify simp can prove porting notes (#10930)

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to

"simp can prove this"
"simp can simplify this`"
"was @[simp], now can be proved by simp"
"was @[simp], but simp can prove it"
"removed simp attribute as the equality can already be obtained by simp"
"simp can already prove this"
"simp already proves this"
"simp can prove these"

d8fa853a

Diff

@@ -163,12 +163,12 @@ theorem add_eq_coe :
   | some a, some b, c => by norm_cast; simp
 #align with_top.add_eq_coe WithTop.add_eq_coe
 
--- Porting note: simp can already prove this.
+-- Porting note (#10618): simp can already prove this.
 -- @[simp]
 theorem add_coe_eq_top_iff {x : WithTop α} {y : α} : x + y = ⊤ ↔ x = ⊤ := by simp
 #align with_top.add_coe_eq_top_iff WithTop.add_coe_eq_top_iff
 
--- Porting note: simp can already prove this.
+-- Porting note (#10618): simp can already prove this.
 -- @[simp]
 theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ := by simp
 #align with_top.coe_add_eq_top_iff WithTop.coe_add_eq_top_iff
@@ -428,7 +428,7 @@ theorem zero_lt_top [OrderedAddCommMonoid α] : (0 : WithTop α) < ⊤ :=
   coe_lt_top 0
 #align with_top.zero_lt_top WithTop.zero_lt_top
 
--- Porting note: simp can already prove this.
+-- Porting note (#10618): simp can already prove this.
 -- @[simp]
 @[norm_cast]
 theorem zero_lt_coe [OrderedAddCommMonoid α] (a : α) : (0 : WithTop α) < a ↔ 0 < a :=
@@ -638,13 +638,13 @@ theorem add_eq_coe : a + b = x ↔ ∃ a' b' : α, ↑a' = a ∧ ↑b' = b ∧ a
   WithTop.add_eq_coe
 #align with_bot.add_eq_coe WithBot.add_eq_coe
 
--- Porting note: simp can already prove this.
+-- Porting note (#10618): simp can already prove this.
 -- @[simp]
 theorem add_coe_eq_bot_iff : a + y = ⊥ ↔ a = ⊥ :=
   WithTop.add_coe_eq_top_iff
 #align with_bot.add_coe_eq_bot_iff WithBot.add_coe_eq_bot_iff
 
--- Porting note: simp can already prove this.
+-- Porting note (#10618): simp can already prove this.
 -- @[simp]
 theorem coe_add_eq_bot_iff : ↑x + b = ⊥ ↔ b = ⊥ :=
   WithTop.coe_add_eq_top_iff

feat: Make the coercion ℝ≥0 → ℝ≥0∞ commute defeqly with nsmul and pow (#10225)

by tweaking the definition of the AddMonoid and MonoidWithZero instances for WithTop. Also unprotect ENNReal.coe_injective and rename ENNReal.coe_eq_coe → ENNReal.coe_inj.

From LeanAPAP

0174e788

Diff

@@ -332,8 +332,18 @@ instance addZeroClass [AddZeroClass α] : AddZeroClass (WithTop α) :=
 section AddMonoid
 variable [AddMonoid α]
 
-instance addMonoid : AddMonoid (WithTop α) :=
-  { WithTop.addSemigroup, WithTop.addZeroClass with }
+instance addMonoid : AddMonoid (WithTop α) where
+  __ := WithTop.addSemigroup
+  __ := WithTop.addZeroClass
+  nsmul n a := match a, n with
+    | (a : α), n => ↑(n • a)
+    | ⊤, 0 => 0
+    | ⊤, _n + 1 => ⊤
+  nsmul_zero a := by cases a <;> simp [zero_nsmul]
+  nsmul_succ n a := by
+    cases a <;> cases n <;> simp [succ_nsmul, coe_add, some_eq_coe, none_eq_top]
+
+@[simp, norm_cast] lemma coe_nsmul (a : α) (n : ℕ) : ↑(n • a) = n • (a : WithTop α) := rfl
 
 /-- Coercion from `α` to `WithTop α` as an `AddMonoidHom`. -/
 def addHom : α →+ WithTop α where
@@ -345,10 +355,6 @@ def addHom : α →+ WithTop α where
 @[simp, norm_cast] lemma coe_addHom : ⇑(addHom : α →+ WithTop α) = WithTop.some := rfl
 #align with_top.coe_coe_add_hom WithTop.coe_addHom
 
-@[simp, norm_cast]
-lemma coe_nsmul (a : α) (n : ℕ) : ↑(n • a) = n • (a : WithTop α) :=
-  (addHom : α →+ WithTop α).map_nsmul _ _
-
 end AddMonoid
 
 instance addCommMonoid [AddCommMonoid α] : AddCommMonoid (WithTop α) :=

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

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

Zulip thread

Important changes

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

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

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

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

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

Similarly, MyEquivClass should take EquivLike as a parameter.

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

Remaining issues

Slower (failing) search

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

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

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

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

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

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

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

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

`simp` not firing sometimes

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

Missing instances due to unification failing

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

Workaround for issues

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

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

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

c6a73d4f

Diff

@@ -303,7 +303,8 @@ protected theorem add_lt_add_of_lt_of_le [Preorder α] [CovariantClass α α (·
 
 --  There is no `WithTop.map_mul_of_mulHom`, since `WithTop` does not have a multiplication.
 @[simp]
-protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : WithTop α) :
+protected theorem map_add {F} [Add β] [FunLike F α β] [AddHomClass F α β]
+    (f : F) (a b : WithTop α) :
     (a + b).map f = a.map f + b.map f := by
   induction a using WithTop.recTopCoe
   · exact (top_add _).symm
@@ -657,7 +658,8 @@ theorem add_left_cancel [IsLeftCancelAdd α] (ha : a ≠ ⊥) (h : a + b = a + c
 
 -- There is no `WithBot.map_mul_of_mulHom`, since `WithBot` does not have a multiplication.
 @[simp]
-protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : WithBot α) :
+protected theorem map_add {F} [Add β] [FunLike F α β] [AddHomClass F α β]
+    (f : F) (a b : WithBot α) :
     (a + b).map f = a.map f + b.map f :=
   WithTop.map_add f a b
 #align with_bot.map_add WithBot.map_add

chore(WithTop): add @[simp] to coe_add (#10204)

208205e6

Diff

@@ -113,7 +113,7 @@ instance add : Add (WithTop α) :=
   ⟨Option.map₂ (· + ·)⟩
 #align with_top.has_add WithTop.add
 
-@[norm_cast] lemma coe_add (a b : α) : ↑(a + b) = (a + b : WithTop α) := rfl
+@[simp, norm_cast] lemma coe_add (a b : α) : ↑(a + b) = (a + b : WithTop α) := rfl
 #align with_top.coe_add WithTop.coe_add
 
 section deprecated
@@ -142,7 +142,10 @@ theorem add_top (a : WithTop α) : a + ⊤ = ⊤ := by cases a <;> rfl
 
 @[simp]
 theorem add_eq_top : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ := by
-  cases a <;> cases b <;> simp [none_eq_top, some_eq_coe, ← WithTop.coe_add]
+  match a, b with
+  | ⊤, _ => simp
+  | _, ⊤ => simp
+  | (a : α), (b : α) => simp only [← coe_add, coe_ne_top, or_false]
 #align with_top.add_eq_top WithTop.add_eq_top
 
 theorem add_ne_top : a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ :=
@@ -580,7 +583,7 @@ section Add
 
 variable [Add α] {a b c d : WithBot α} {x y : α}
 
--- `norm_cast` proves those lemmas, because `WithTop`/`WithBot` are reducible
+@[simp, norm_cast]
 theorem coe_add (a b : α) : ((a + b : α) : WithBot α) = a + b :=
   rfl
 #align with_bot.coe_add WithBot.coe_add

chore(WithTop): less abuse of defeq to Option _ (#9986)

Also reuse proofs here and there.

9cc09f63

Diff

@@ -155,22 +155,19 @@ theorem add_lt_top [LT α] {a b : WithTop α} : a + b < ⊤ ↔ a < ⊤ ∧ b <
 
 theorem add_eq_coe :
     ∀ {a b : WithTop α} {c : α}, a + b = c ↔ ∃ a' b' : α, ↑a' = a ∧ ↑b' = b ∧ a' + b' = c
-  | none, b, c => by simp [none_eq_top]
-  | Option.some a, none, c => by simp [none_eq_top]
-  | Option.some a, Option.some b, c =>
-  by simp only [some_eq_coe, ← coe_add, coe_eq_coe, exists_and_left, exists_eq_left]
+  | ⊤, b, c => by simp
+  | some a, ⊤, c => by simp
+  | some a, some b, c => by norm_cast; simp
 #align with_top.add_eq_coe WithTop.add_eq_coe
 
 -- Porting note: simp can already prove this.
 -- @[simp]
-theorem add_coe_eq_top_iff {x : WithTop α} {y : α} : x + y = ⊤ ↔ x = ⊤ := by
-  induction x using WithTop.recTopCoe <;> simp [← coe_add]
+theorem add_coe_eq_top_iff {x : WithTop α} {y : α} : x + y = ⊤ ↔ x = ⊤ := by simp
 #align with_top.add_coe_eq_top_iff WithTop.add_coe_eq_top_iff
 
 -- Porting note: simp can already prove this.
 -- @[simp]
-theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ := by
-  induction y using WithTop.recTopCoe <;> simp [← coe_add]
+theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ := by simp
 #align with_top.coe_add_eq_top_iff WithTop.coe_add_eq_top_iff
 
 theorem add_right_cancel_iff [IsRightCancelAdd α] (ha : a ≠ ⊤) : b + a = c + a ↔ b = c := by
@@ -364,8 +361,7 @@ instance addMonoidWithOne : AddMonoidWithOne (WithTop α) :=
       rw [Nat.cast_zero, WithTop.coe_zero],
     natCast_succ := fun n => by
       simp only -- Porting note: Had to add this...?
-      rw [Nat.cast_add_one, WithTop.coe_add, WithTop.coe_one]
-  }
+      rw [Nat.cast_add_one, WithTop.coe_add, WithTop.coe_one] }
 
 @[simp, norm_cast] lemma coe_nat (n : ℕ) : ((n : α) : WithTop α) = n := rfl
 #align with_top.coe_nat WithTop.coe_nat
@@ -385,14 +381,8 @@ instance charZero [AddMonoidWithOne α] [CharZero α] : CharZero (WithTop α) :=
 instance addCommMonoidWithOne [AddCommMonoidWithOne α] : AddCommMonoidWithOne (WithTop α) :=
   { WithTop.addMonoidWithOne, WithTop.addCommMonoid with }
 
-instance orderedAddCommMonoid [OrderedAddCommMonoid α] : OrderedAddCommMonoid (WithTop α) :=
-  { WithTop.partialOrder, WithTop.addCommMonoid with
-    add_le_add_left := by
-      rintro a b h (_ | c); · simp [none_eq_top]
-      rcases b with (_ | b); · simp [none_eq_top]
-      rcases le_coe_iff.1 h with ⟨a, rfl, _⟩
-      simp only [some_eq_coe, ← coe_add, coe_le_coe] at h ⊢
-      exact add_le_add_left h c }
+instance orderedAddCommMonoid [OrderedAddCommMonoid α] : OrderedAddCommMonoid (WithTop α) where
+  add_le_add_left _ _ := add_le_add_left
 
 instance linearOrderedAddCommMonoidWithTop [LinearOrderedAddCommMonoid α] :
     LinearOrderedAddCommMonoidWithTop (WithTop α) :=

chore: reduce imports (#9830)

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

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

f4c4ca61

Diff

@@ -5,10 +5,11 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
 import Mathlib.Algebra.CharZero.Defs
 import Mathlib.Algebra.Group.Hom.Defs
+import Mathlib.Algebra.Order.Monoid.Canonical.Defs
 import Mathlib.Algebra.Order.Monoid.OrderDual
-import Mathlib.Algebra.Order.Monoid.WithZero.Basic
 import Mathlib.Algebra.Order.ZeroLEOne
 import Mathlib.Data.Nat.Cast.Defs
+import Mathlib.Order.WithBot
 
 #align_import algebra.order.monoid.with_top from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"

feat: More WithBot lemmas (#9580)

This makes simp stronger on WithBot, for use in #9083.

Also reorder the relevant lemmas so that the WithTop and WithBot sections are more identical.

fb274b38

Diff

@@ -25,7 +25,7 @@ namespace WithTop
 
 section One
 
-variable [One α]
+variable [One α] {a : α}
 
 @[to_additive]
 instance one : One (WithTop α) :=
@@ -40,11 +40,23 @@ theorem coe_one : ((1 : α) : WithTop α) = 1 :=
 #align with_top.coe_zero WithTop.coe_zero
 
 @[to_additive (attr := simp, norm_cast)]
-theorem coe_eq_one {a : α} : (a : WithTop α) = 1 ↔ a = 1 :=
-  coe_eq_coe
+lemma coe_eq_one : (a : WithTop α) = 1 ↔ a = 1 := coe_eq_coe
 #align with_top.coe_eq_one WithTop.coe_eq_one
 #align with_top.coe_eq_zero WithTop.coe_eq_zero
 
+@[to_additive (attr := simp, norm_cast)]
+lemma one_eq_coe : 1 = (a : WithTop α) ↔ a = 1 := eq_comm.trans coe_eq_one
+#align with_top.one_eq_coe WithTop.one_eq_coe
+#align with_top.zero_eq_coe WithTop.zero_eq_coe
+
+@[to_additive (attr := simp)] lemma top_ne_one : (⊤ : WithTop α) ≠ 1 := top_ne_coe
+#align with_top.top_ne_one WithTop.top_ne_one
+#align with_top.top_ne_zero WithTop.top_ne_zero
+
+@[to_additive (attr := simp)] lemma one_ne_top : (1 : WithTop α) ≠ ⊤ := coe_ne_top
+#align with_top.one_ne_top WithTop.one_ne_top
+#align with_top.zero_ne_top WithTop.zero_ne_top
+
 @[to_additive (attr := simp)]
 theorem untop_one : (1 : WithTop α).untop coe_ne_top = 1 :=
   rfl
@@ -87,24 +99,6 @@ protected theorem map_one {β} (f : α → β) : (1 : WithTop α).map f = (f 1 :
 #align with_top.map_one WithTop.map_one
 #align with_top.map_zero WithTop.map_zero
 
-@[to_additive (attr := simp, norm_cast)]
-theorem one_eq_coe {a : α} : 1 = (a : WithTop α) ↔ a = 1 :=
-  Trans.trans eq_comm coe_eq_one
-#align with_top.one_eq_coe WithTop.one_eq_coe
-#align with_top.zero_eq_coe WithTop.zero_eq_coe
-
-@[to_additive (attr := simp)]
-theorem top_ne_one : ⊤ ≠ (1 : WithTop α) :=
-  fun.
-#align with_top.top_ne_one WithTop.top_ne_one
-#align with_top.top_ne_zero WithTop.top_ne_zero
-
-@[to_additive (attr := simp)]
-theorem one_ne_top : (1 : WithTop α) ≠ ⊤ :=
-  fun.
-#align with_top.one_ne_top WithTop.one_ne_top
-#align with_top.zero_ne_top WithTop.zero_ne_top
-
 instance zeroLEOneClass [Zero α] [LE α] [ZeroLEOneClass α] : ZeroLEOneClass (WithTop α) :=
   ⟨some_le_some.2 zero_le_one⟩
 
@@ -471,10 +465,68 @@ protected def _root_.AddMonoidHom.withTopMap {M N : Type*} [AddZeroClass M] [Add
 end WithTop
 
 namespace WithBot
+section One
+variable [One α] {a : α}
 
-@[to_additive]
-instance one [One α] : One (WithBot α) :=
-  WithTop.one
+@[to_additive] instance one : One (WithBot α) := WithTop.one
+
+@[to_additive (attr := simp, norm_cast)] lemma coe_one : ((1 : α) : WithBot α) = 1 := rfl
+#align with_bot.coe_one WithBot.coe_one
+#align with_bot.coe_zero WithBot.coe_zero
+
+@[to_additive (attr := simp, norm_cast)]
+lemma coe_eq_one : (a : WithBot α) = 1 ↔ a = 1 := coe_eq_coe
+#align with_bot.coe_eq_one WithBot.coe_eq_one
+#align with_bot.coe_eq_zero WithBot.coe_eq_zero
+
+@[to_additive (attr := simp, norm_cast)]
+lemma one_eq_coe : 1 = (a : WithBot α) ↔ a = 1 := eq_comm.trans coe_eq_one
+
+@[to_additive (attr := simp)] lemma bot_ne_one : (⊥ : WithBot α) ≠ 1 := bot_ne_coe
+@[to_additive (attr := simp)] lemma one_ne_bot : (1 : WithBot α) ≠ ⊥ := coe_ne_bot
+
+@[to_additive (attr := simp)]
+theorem unbot_one [One α] : (1 : WithBot α).unbot coe_ne_bot = 1 :=
+  rfl
+#align with_bot.unbot_one WithBot.unbot_one
+#align with_bot.unbot_zero WithBot.unbot_zero
+
+@[to_additive (attr := simp)]
+theorem unbot_one' (d : α) : (1 : WithBot α).unbot' d = 1 :=
+  rfl
+#align with_bot.unbot_one' WithBot.unbot_one'
+#align with_bot.unbot_zero' WithBot.unbot_zero'
+
+@[to_additive (attr := simp, norm_cast) coe_nonneg]
+theorem one_le_coe [LE α] : 1 ≤ (a : WithBot α) ↔ 1 ≤ a := coe_le_coe
+#align with_bot.one_le_coe WithBot.one_le_coe
+#align with_bot.coe_nonneg WithBot.coe_nonneg
+
+@[to_additive (attr := simp, norm_cast) coe_le_zero]
+theorem coe_le_one [LE α] : (a : WithBot α) ≤ 1 ↔ a ≤ 1 := coe_le_coe
+#align with_bot.coe_le_one WithBot.coe_le_one
+#align with_bot.coe_le_zero WithBot.coe_le_zero
+
+@[to_additive (attr := simp, norm_cast) coe_pos]
+theorem one_lt_coe [LT α] : 1 < (a : WithBot α) ↔ 1 < a := coe_lt_coe
+#align with_bot.one_lt_coe WithBot.one_lt_coe
+#align with_bot.coe_pos WithBot.coe_pos
+
+@[to_additive (attr := simp, norm_cast) coe_lt_zero]
+theorem coe_lt_one [LT α] : (a : WithBot α) < 1 ↔ a < 1 := coe_lt_coe
+#align with_bot.coe_lt_one WithBot.coe_lt_one
+#align with_bot.coe_lt_zero WithBot.coe_lt_zero
+
+@[to_additive (attr := simp)]
+protected theorem map_one {β} (f : α → β) : (1 : WithBot α).map f = (f 1 : WithBot β) :=
+  rfl
+#align with_bot.map_one WithBot.map_one
+#align with_bot.map_zero WithBot.map_zero
+
+instance zeroLEOneClass [Zero α] [LE α] [ZeroLEOneClass α] : ZeroLEOneClass (WithBot α) :=
+  ⟨some_le_some.2 zero_le_one⟩
+
+end One
 
 instance add [Add α] : Add (WithBot α) :=
   WithTop.add
@@ -533,65 +585,6 @@ instance charZero [AddMonoidWithOne α] [CharZero α] : CharZero (WithBot α) :=
 instance addCommMonoidWithOne [AddCommMonoidWithOne α] : AddCommMonoidWithOne (WithBot α) :=
   WithTop.addCommMonoidWithOne
 
-instance zeroLEOneClass [Zero α] [One α] [LE α] [ZeroLEOneClass α] : ZeroLEOneClass (WithBot α) :=
-  ⟨some_le_some.2 zero_le_one⟩
-
--- `by norm_cast` proves this lemma, so I did not tag it with `norm_cast`
-@[to_additive]
-theorem coe_one [One α] : ((1 : α) : WithBot α) = 1 :=
-  rfl
-#align with_bot.coe_one WithBot.coe_one
-#align with_bot.coe_zero WithBot.coe_zero
-
--- `by norm_cast` proves this lemma, so I did not tag it with `norm_cast`
-@[to_additive]
-theorem coe_eq_one [One α] {a : α} : (a : WithBot α) = 1 ↔ a = 1 :=
-  WithTop.coe_eq_one
-#align with_bot.coe_eq_one WithBot.coe_eq_one
-#align with_bot.coe_eq_zero WithBot.coe_eq_zero
-
-@[to_additive (attr := simp)]
-theorem unbot_one [One α] : (1 : WithBot α).unbot coe_ne_bot = 1 :=
-  rfl
-#align with_bot.unbot_one WithBot.unbot_one
-#align with_bot.unbot_zero WithBot.unbot_zero
-
-@[to_additive (attr := simp)]
-theorem unbot_one' [One α] (d : α) : (1 : WithBot α).unbot' d = 1 :=
-  rfl
-#align with_bot.unbot_one' WithBot.unbot_one'
-#align with_bot.unbot_zero' WithBot.unbot_zero'
-
-@[to_additive (attr := simp, norm_cast) coe_nonneg]
-theorem one_le_coe [One α] [LE α] {a : α} : 1 ≤ (a : WithBot α) ↔ 1 ≤ a :=
-  coe_le_coe
-#align with_bot.one_le_coe WithBot.one_le_coe
-#align with_bot.coe_nonneg WithBot.coe_nonneg
-
-@[to_additive (attr := simp, norm_cast) coe_le_zero]
-theorem coe_le_one [One α] [LE α] {a : α} : (a : WithBot α) ≤ 1 ↔ a ≤ 1 :=
-  coe_le_coe
-#align with_bot.coe_le_one WithBot.coe_le_one
-#align with_bot.coe_le_zero WithBot.coe_le_zero
-
-@[to_additive (attr := simp, norm_cast) coe_pos]
-theorem one_lt_coe [One α] [LT α] {a : α} : 1 < (a : WithBot α) ↔ 1 < a :=
-  coe_lt_coe
-#align with_bot.one_lt_coe WithBot.one_lt_coe
-#align with_bot.coe_pos WithBot.coe_pos
-
-@[to_additive (attr := simp, norm_cast) coe_lt_zero]
-theorem coe_lt_one [One α] [LT α] {a : α} : (a : WithBot α) < 1 ↔ a < 1 :=
-  coe_lt_coe
-#align with_bot.coe_lt_one WithBot.coe_lt_one
-#align with_bot.coe_lt_zero WithBot.coe_lt_zero
-
-@[to_additive (attr := simp)]
-protected theorem map_one {β} [One α] (f : α → β) : (1 : WithBot α).map f = (f 1 : WithBot β) :=
-  rfl
-#align with_bot.map_one WithBot.map_one
-#align with_bot.map_zero WithBot.map_zero
-
 section Add
 
 variable [Add α] {a b c d : WithBot α} {x y : α}

chore: Move WithTop lemmas earlier (#9463)

Part of #9411

4fc93c28

Diff

@@ -118,9 +118,7 @@ instance add : Add (WithTop α) :=
   ⟨Option.map₂ (· + ·)⟩
 #align with_top.has_add WithTop.add
 
-@[norm_cast]
-theorem coe_add : ((x + y : α) : WithTop α) = x + y :=
-  rfl
+@[norm_cast] lemma coe_add (a b : α) : ↑(a + b) = (a + b : WithTop α) := rfl
 #align with_top.coe_add WithTop.coe_add
 
 section deprecated
@@ -335,13 +333,35 @@ instance addZeroClass [AddZeroClass α] : AddZeroClass (WithTop α) :=
     zero_add := Option.map₂_left_identity zero_add
     add_zero := Option.map₂_right_identity add_zero }
 
-instance addMonoid [AddMonoid α] : AddMonoid (WithTop α) :=
+section AddMonoid
+variable [AddMonoid α]
+
+instance addMonoid : AddMonoid (WithTop α) :=
   { WithTop.addSemigroup, WithTop.addZeroClass with }
 
+/-- Coercion from `α` to `WithTop α` as an `AddMonoidHom`. -/
+def addHom : α →+ WithTop α where
+  toFun := WithTop.some
+  map_zero' := rfl
+  map_add' _ _ := rfl
+#align with_top.coe_add_hom WithTop.addHom
+
+@[simp, norm_cast] lemma coe_addHom : ⇑(addHom : α →+ WithTop α) = WithTop.some := rfl
+#align with_top.coe_coe_add_hom WithTop.coe_addHom
+
+@[simp, norm_cast]
+lemma coe_nsmul (a : α) (n : ℕ) : ↑(n • a) = n • (a : WithTop α) :=
+  (addHom : α →+ WithTop α).map_nsmul _ _
+
+end AddMonoid
+
 instance addCommMonoid [AddCommMonoid α] : AddCommMonoid (WithTop α) :=
   { WithTop.addMonoid, WithTop.addCommSemigroup with }
 
-instance addMonoidWithOne [AddMonoidWithOne α] : AddMonoidWithOne (WithTop α) :=
+section AddMonoidWithOne
+variable [AddMonoidWithOne α]
+
+instance addMonoidWithOne : AddMonoidWithOne (WithTop α) :=
   { WithTop.one, WithTop.addMonoid with
     natCast := fun n => ↑(n : α),
     natCast_zero := by
@@ -352,6 +372,17 @@ instance addMonoidWithOne [AddMonoidWithOne α] : AddMonoidWithOne (WithTop α)
       rw [Nat.cast_add_one, WithTop.coe_add, WithTop.coe_one]
   }
 
+@[simp, norm_cast] lemma coe_nat (n : ℕ) : ((n : α) : WithTop α) = n := rfl
+#align with_top.coe_nat WithTop.coe_nat
+
+@[simp] lemma nat_ne_top (n : ℕ) : (n : WithTop α) ≠ ⊤ := coe_ne_top
+#align with_top.nat_ne_top WithTop.nat_ne_top
+
+@[simp] lemma top_ne_nat (n : ℕ) : (⊤ : WithTop α) ≠ n := top_ne_coe
+#align with_top.top_ne_nat WithTop.top_ne_nat
+
+end AddMonoidWithOne
+
 instance charZero [AddMonoidWithOne α] [CharZero α] : CharZero (WithTop α) :=
   { cast_injective := Function.Injective.comp (f := Nat.cast (R := α))
       (fun _ _ => WithTop.coe_eq_coe.1) Nat.cast_injective}
@@ -397,36 +428,6 @@ instance [CanonicallyLinearOrderedAddCommMonoid α] :
     CanonicallyLinearOrderedAddCommMonoid (WithTop α) :=
   { WithTop.canonicallyOrderedAddCommMonoid, WithTop.linearOrder with }
 
-@[simp, norm_cast]
-theorem coe_nat [AddMonoidWithOne α] (n : ℕ) : ((n : α) : WithTop α) = n :=
-  rfl
-#align with_top.coe_nat WithTop.coe_nat
-
-@[simp]
-theorem nat_ne_top [AddMonoidWithOne α] (n : ℕ) : (n : WithTop α) ≠ ⊤ :=
-  coe_ne_top
-#align with_top.nat_ne_top WithTop.nat_ne_top
-
-@[simp]
-theorem top_ne_nat [AddMonoidWithOne α] (n : ℕ) : (⊤ : WithTop α) ≠ n :=
-  top_ne_coe
-#align with_top.top_ne_nat WithTop.top_ne_nat
-
-/-- Coercion from `α` to `WithTop α` as an `AddMonoidHom`. -/
-def addHom [AddMonoid α] : α →+ WithTop α :=
-  -- Porting note: why does the old proof not work?
-  -- ⟨WithTop.some, rfl, fun _ _ => rfl⟩
-  { toFun := WithTop.some,
-    map_zero' := rfl,
-    map_add' := fun _ _ => rfl }
-#align with_top.coe_add_hom WithTop.addHom
-
--- Porting note: It seems like that kind of coe-lemmas is not needed anymore.
--- @[simp]
--- theorem coe_coe_add_hom [AddMonoid α] : (coeAddHom : α →+ WithTop α).toFun = WithTop.some :=
---   rfl
--- #align with_top.coe_coe_add_hom WithTop.coe_coe_add_hom
-
 @[simp]
 theorem zero_lt_top [OrderedAddCommMonoid α] : (0 : WithTop α) < ⊤ :=
   coe_lt_top 0
@@ -487,14 +488,44 @@ instance addCommSemigroup [AddCommSemigroup α] : AddCommSemigroup (WithBot α)
 instance addZeroClass [AddZeroClass α] : AddZeroClass (WithBot α) :=
   WithTop.addZeroClass
 
-instance addMonoid [AddMonoid α] : AddMonoid (WithBot α) :=
-  WithTop.addMonoid
+section AddMonoid
+variable [AddMonoid α]
+
+instance addMonoid : AddMonoid (WithBot α) := WithTop.addMonoid
+
+/-- Coercion from `α` to `WithBot α` as an `AddMonoidHom`. -/
+def addHom : α →+ WithBot α where
+  toFun := WithTop.some
+  map_zero' := rfl
+  map_add' _ _ := rfl
+
+@[simp, norm_cast] lemma coe_addHom : ⇑(addHom : α →+ WithBot α) = WithBot.some := rfl
+
+@[simp, norm_cast]
+lemma coe_nsmul (a : α) (n : ℕ) : ↑(n • a) = n • (a : WithBot α) :=
+  (addHom : α →+ WithBot α).map_nsmul _ _
+#align with_bot.coe_nsmul WithBot.coe_nsmul
+
+end AddMonoid
 
 instance addCommMonoid [AddCommMonoid α] : AddCommMonoid (WithBot α) :=
   WithTop.addCommMonoid
 
-instance addMonoidWithOne [AddMonoidWithOne α] : AddMonoidWithOne (WithBot α) :=
-  WithTop.addMonoidWithOne
+section AddMonoidWithOne
+variable [AddMonoidWithOne α]
+
+instance addMonoidWithOne : AddMonoidWithOne (WithBot α) := WithTop.addMonoidWithOne
+
+@[norm_cast] lemma coe_nat (n : ℕ) : ((n : α) : WithBot α) = n := rfl
+#align with_bot.coe_nat WithBot.coe_nat
+
+@[simp] lemma nat_ne_bot (n : ℕ) : (n : WithBot α) ≠ ⊥ := coe_ne_bot
+#align with_bot.nat_ne_bot WithBot.nat_ne_bot
+
+@[simp] lemma bot_ne_nat (n : ℕ) : (⊥ : WithBot α) ≠ n := bot_ne_coe
+#align with_bot.bot_ne_nat WithBot.bot_ne_nat
+
+end AddMonoidWithOne
 
 instance charZero [AddMonoidWithOne α] [CharZero α] : CharZero (WithBot α) :=
   WithTop.charZero
@@ -561,21 +592,6 @@ protected theorem map_one {β} [One α] (f : α → β) : (1 : WithBot α).map f
 #align with_bot.map_one WithBot.map_one
 #align with_bot.map_zero WithBot.map_zero
 
-@[norm_cast]
-theorem coe_nat [AddMonoidWithOne α] (n : ℕ) : ((n : α) : WithBot α) = n :=
-  rfl
-#align with_bot.coe_nat WithBot.coe_nat
-
-@[simp]
-theorem nat_ne_bot [AddMonoidWithOne α] (n : ℕ) : (n : WithBot α) ≠ ⊥ :=
-  coe_ne_bot
-#align with_bot.nat_ne_bot WithBot.nat_ne_bot
-
-@[simp]
-theorem bot_ne_nat [AddMonoidWithOne α] (n : ℕ) : (⊥ : WithBot α) ≠ n :=
-  bot_ne_coe
-#align with_bot.bot_ne_nat WithBot.bot_ne_nat
-
 section Add
 
 variable [Add α] {a b c d : WithBot α} {x y : α}

refactor: replace some [@foo](https://github.com/foo) _ _ _ _ _ ... by named arguments (#8702)

Using Lean4's named arguments, we manage to remove a few hard-to-read explicit function calls [@foo](https://github.com/foo) _ _ _ _ _ ... which used to be necessary in Lean3.

Occasionally, this results in slightly longer code. The benefit of named arguments is readability, as well as to reduce the brittleness of the code when the argument order is changed.

Co-authored-by: Michael Rothgang <rothgami@math.hu-berlin.de>

df634f2a

Diff

@@ -621,7 +621,7 @@ theorem add_ne_bot : a + b ≠ ⊥ ↔ a ≠ ⊥ ∧ b ≠ ⊥ :=
 #align with_bot.add_ne_bot WithBot.add_ne_bot
 
 theorem bot_lt_add [LT α] {a b : WithBot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b :=
-  @WithTop.add_lt_top αᵒᵈ _ _ _ _
+  WithTop.add_lt_top (α := αᵒᵈ)
 #align with_bot.bot_lt_add WithBot.bot_lt_add
 
 theorem add_eq_coe : a + b = x ↔ ∃ a' b' : α, ↑a' = a ∧ ↑b' = b ∧ a' + b' = x :=
@@ -692,42 +692,42 @@ variable [Preorder α]
 
 instance covariantClass_add_le [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (· + ·) (· ≤ ·) :=
-  @OrderDual.covariantClass_add_le (WithTop αᵒᵈ) _ _ _
+  OrderDual.covariantClass_add_le (α := WithTop αᵒᵈ)
 #align with_bot.covariant_class_add_le WithBot.covariantClass_add_le
 
 instance covariantClass_swap_add_le [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· ≤ ·) :=
-  @OrderDual.covariantClass_swap_add_le (WithTop αᵒᵈ) _ _ _
+  OrderDual.covariantClass_swap_add_le (α := WithTop αᵒᵈ)
 #align with_bot.covariant_class_swap_add_le WithBot.covariantClass_swap_add_le
 
 instance contravariantClass_add_lt [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (· + ·) (· < ·) :=
-  @OrderDual.contravariantClass_add_lt (WithTop αᵒᵈ) _ _ _
+  OrderDual.contravariantClass_add_lt (α := WithTop αᵒᵈ)
 #align with_bot.contravariant_class_add_lt WithBot.contravariantClass_add_lt
 
 instance contravariantClass_swap_add_lt [ContravariantClass α α (swap (· + ·)) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· < ·) :=
-  @OrderDual.contravariantClass_swap_add_lt (WithTop αᵒᵈ) _ _ _
+  OrderDual.contravariantClass_swap_add_lt (α := WithTop αᵒᵈ)
 #align with_bot.contravariant_class_swap_add_lt WithBot.contravariantClass_swap_add_lt
 
 protected theorem le_of_add_le_add_left [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥)
     (h : a + b ≤ a + c) : b ≤ c :=
-  @WithTop.le_of_add_le_add_left αᵒᵈ _ _ _ _ _ _ ha h
+  WithTop.le_of_add_le_add_left (α := αᵒᵈ) ha h
 #align with_bot.le_of_add_le_add_left WithBot.le_of_add_le_add_left
 
 protected theorem le_of_add_le_add_right [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊥) (h : b + a ≤ c + a) : b ≤ c :=
-  @WithTop.le_of_add_le_add_right αᵒᵈ _ _ _ _ _ _ ha h
+  WithTop.le_of_add_le_add_right (α := αᵒᵈ) ha h
 #align with_bot.le_of_add_le_add_right WithBot.le_of_add_le_add_right
 
 protected theorem add_lt_add_left [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) (h : b < c) :
     a + b < a + c :=
-  @WithTop.add_lt_add_left αᵒᵈ _ _ _ _ _ _ ha h
+  WithTop.add_lt_add_left (α := αᵒᵈ) ha h
 #align with_bot.add_lt_add_left WithBot.add_lt_add_left
 
 protected theorem add_lt_add_right [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥)
     (h : b < c) : b + a < c + a :=
-  @WithTop.add_lt_add_right αᵒᵈ _ _ _ _ _ _ ha h
+  WithTop.add_lt_add_right (α := αᵒᵈ) ha h
 #align with_bot.add_lt_add_right WithBot.add_lt_add_right
 
 protected theorem add_le_add_iff_left [CovariantClass α α (· + ·) (· ≤ ·)]
@@ -753,13 +753,13 @@ protected theorem add_lt_add_iff_right [CovariantClass α α (swap (· + ·)) (
 protected theorem add_lt_add_of_le_of_lt [CovariantClass α α (· + ·) (· < ·)]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (hb : b ≠ ⊥) (hab : a ≤ b) (hcd : c < d) :
     a + c < b + d :=
-  @WithTop.add_lt_add_of_le_of_lt αᵒᵈ _ _ _ _ _ _ _ _ hb hab hcd
+  WithTop.add_lt_add_of_le_of_lt (α := αᵒᵈ) hb hab hcd
 #align with_bot.add_lt_add_of_le_of_lt WithBot.add_lt_add_of_le_of_lt
 
 protected theorem add_lt_add_of_lt_of_le [CovariantClass α α (· + ·) (· ≤ ·)]
     [CovariantClass α α (swap (· + ·)) (· < ·)] (hd : d ≠ ⊥) (hab : a < b) (hcd : c ≤ d) :
     a + c < b + d :=
-  @WithTop.add_lt_add_of_lt_of_le αᵒᵈ _ _ _ _ _ _ _ _ hd hab hcd
+  WithTop.add_lt_add_of_lt_of_le (α := αᵒᵈ) hd hab hcd
 #align with_bot.add_lt_add_of_lt_of_le WithBot.add_lt_add_of_lt_of_le
 
 end Add

chore: space after ← (#8178)

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

5fb9beab

Diff

@@ -185,7 +185,7 @@ theorem add_right_cancel_iff [IsRightCancelAdd α] (ha : a ≠ ⊤) : b + a = c
   obtain rfl | hb := (eq_or_ne b ⊤)
   · rw [top_add, eq_comm, WithTop.add_coe_eq_top_iff, eq_comm]
   lift b to α using hb
-  simp_rw [←WithTop.coe_add, eq_comm, WithTop.add_eq_coe, coe_eq_coe, exists_and_left,
+  simp_rw [← WithTop.coe_add, eq_comm, WithTop.add_eq_coe, coe_eq_coe, exists_and_left,
     exists_eq_left, add_left_inj, exists_eq_right, eq_comm]
 
 theorem add_right_cancel [IsRightCancelAdd α] (ha : a ≠ ⊤) (h : b + a = c + a) : b = c :=
@@ -196,7 +196,7 @@ theorem add_left_cancel_iff [IsLeftCancelAdd α] (ha : a ≠ ⊤) : a + b = a +
   obtain rfl | hb := (eq_or_ne b ⊤)
   · rw [add_top, eq_comm, WithTop.coe_add_eq_top_iff, eq_comm]
   lift b to α using hb
-  simp_rw [←WithTop.coe_add, eq_comm, WithTop.add_eq_coe, eq_comm, coe_eq_coe,
+  simp_rw [← WithTop.coe_add, eq_comm, WithTop.add_eq_coe, eq_comm, coe_eq_coe,
     exists_and_left, exists_eq_left', add_right_inj, exists_eq_right']
 
 theorem add_left_cancel [IsLeftCancelAdd α] (ha : a ≠ ⊤) (h : a + b = a + c) : b = c :=

https://github.com/leanprover-community/mathlib4/blob/4055c8b471380825f07416b12cb0cf266da44d84/Mathlib/Tactic/Simps/Basic.lean#L843-L851

style: shorten simps configurations (#8296)

Use .asFn and .lemmasOnly as simps configuration options.

For reference, these are defined here:

e0637173

Diff

@@ -440,7 +440,7 @@ theorem zero_lt_coe [OrderedAddCommMonoid α] (a : α) : (0 : WithTop α) < a 
 #align with_top.zero_lt_coe WithTop.zero_lt_coe
 
 /-- A version of `WithTop.map` for `OneHom`s. -/
-@[to_additive (attr := simps (config := { fullyApplied := false }))
+@[to_additive (attr := simps (config := .asFn))
   "A version of `WithTop.map` for `ZeroHom`s"]
 protected def _root_.OneHom.withTopMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
     OneHom (WithTop M) (WithTop N) where
@@ -451,7 +451,7 @@ protected def _root_.OneHom.withTopMap {M N : Type*} [One M] [One N] (f : OneHom
 #align one_hom.with_top_map_apply OneHom.withTopMap_apply
 
 /-- A version of `WithTop.map` for `AddHom`s. -/
-@[simps (config := { fullyApplied := false })]
+@[simps (config := .asFn)]
 protected def _root_.AddHom.withTopMap {M N : Type*} [Add M] [Add N] (f : AddHom M N) :
     AddHom (WithTop M) (WithTop N) where
   toFun := WithTop.map f
@@ -460,7 +460,7 @@ protected def _root_.AddHom.withTopMap {M N : Type*} [Add M] [Add N] (f : AddHom
 #align add_hom.with_top_map_apply AddHom.withTopMap_apply
 
 /-- A version of `WithTop.map` for `AddMonoidHom`s. -/
-@[simps (config := { fullyApplied := false })]
+@[simps (config := .asFn)]
 protected def _root_.AddMonoidHom.withTopMap {M N : Type*} [AddZeroClass M] [AddZeroClass N]
     (f : M →+ N) : WithTop M →+ WithTop N :=
   { ZeroHom.withTopMap f.toZeroHom, AddHom.withTopMap f.toAddHom with toFun := WithTop.map f }
@@ -660,7 +660,7 @@ protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : With
 #align with_bot.map_add WithBot.map_add
 
 /-- A version of `WithBot.map` for `OneHom`s. -/
-@[to_additive (attr := simps (config := { fullyApplied := false }))
+@[to_additive (attr := simps (config := .asFn))
   "A version of `WithBot.map` for `ZeroHom`s"]
 protected def _root_.OneHom.withBotMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
     OneHom (WithBot M) (WithBot N) where
@@ -672,7 +672,7 @@ protected def _root_.OneHom.withBotMap {M N : Type*} [One M] [One N] (f : OneHom
 #align zero_hom.with_bot_map_apply ZeroHom.withBotMap_apply
 
 /-- A version of `WithBot.map` for `AddHom`s. -/
-@[simps (config := { fullyApplied := false })]
+@[simps (config := .asFn)]
 protected def _root_.AddHom.withBotMap {M N : Type*} [Add M] [Add N] (f : AddHom M N) :
     AddHom (WithBot M) (WithBot N) where
   toFun := WithBot.map f
@@ -681,7 +681,7 @@ protected def _root_.AddHom.withBotMap {M N : Type*} [Add M] [Add N] (f : AddHom
 #align add_hom.with_bot_map_apply AddHom.withBotMap_apply
 
 /-- A version of `WithBot.map` for `AddMonoidHom`s. -/
-@[simps (config := { fullyApplied := false })]
+@[simps (config := .asFn)]
 protected def _root_.AddMonoidHom.withBotMap {M N : Type*} [AddZeroClass M] [AddZeroClass N]
     (f : M →+ N) : WithBot M →+ WithBot N :=
   { ZeroHom.withBotMap f.toZeroHom, AddHom.withBotMap f.toAddHom with toFun := WithBot.map f }

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

I believe the file defining a type of morphisms belongs alongside the file defining the structure this morphism works on. So I would like to reorganize the files in the Mathlib.Algebra.Hom folder so that e.g. Mathlib.Algebra.Hom.Ring becomes Mathlib.Algebra.Ring.Hom and Mathlib.Algebra.Hom.NonUnitalAlg becomes Mathlib.Algebra.Algebra.NonUnitalHom.

While fixing the imports I went ahead and sorted them for good luck.

The full list of changes is: renamed: Mathlib/Algebra/Hom/NonUnitalAlg.lean -> Mathlib/Algebra/Algebra/NonUnitalHom.lean renamed: Mathlib/Algebra/Hom/Aut.lean -> Mathlib/Algebra/Group/Aut.lean renamed: Mathlib/Algebra/Hom/Commute.lean -> Mathlib/Algebra/Group/Commute/Hom.lean renamed: Mathlib/Algebra/Hom/Embedding.lean -> Mathlib/Algebra/Group/Embedding.lean renamed: Mathlib/Algebra/Hom/Equiv/Basic.lean -> Mathlib/Algebra/Group/Equiv/Basic.lean renamed: Mathlib/Algebra/Hom/Equiv/TypeTags.lean -> Mathlib/Algebra/Group/Equiv/TypeTags.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/Basic.lean -> Mathlib/Algebra/Group/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Equiv/Units/GroupWithZero.lean -> Mathlib/Algebra/GroupWithZero/Units/Equiv.lean renamed: Mathlib/Algebra/Hom/Freiman.lean -> Mathlib/Algebra/Group/Freiman.lean renamed: Mathlib/Algebra/Hom/Group/Basic.lean -> Mathlib/Algebra/Group/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Group/Defs.lean -> Mathlib/Algebra/Group/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/GroupAction.lean -> Mathlib/GroupTheory/GroupAction/Hom.lean renamed: Mathlib/Algebra/Hom/GroupInstances.lean -> Mathlib/Algebra/Group/Hom/Instances.lean renamed: Mathlib/Algebra/Hom/Iterate.lean -> Mathlib/Algebra/GroupPower/IterateHom.lean renamed: Mathlib/Algebra/Hom/Centroid.lean -> Mathlib/Algebra/Ring/CentroidHom.lean renamed: Mathlib/Algebra/Hom/Ring/Basic.lean -> Mathlib/Algebra/Ring/Hom/Basic.lean renamed: Mathlib/Algebra/Hom/Ring/Defs.lean -> Mathlib/Algebra/Ring/Hom/Defs.lean renamed: Mathlib/Algebra/Hom/Units.lean -> Mathlib/Algebra/Group/Units/Hom.lean

Zulip thread: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Reorganizing.20.60Mathlib.2EAlgebra.2EHom.60

92fe122e

Diff

@@ -3,12 +3,12 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Mathlib.Algebra.Hom.Group.Defs
+import Mathlib.Algebra.CharZero.Defs
+import Mathlib.Algebra.Group.Hom.Defs
 import Mathlib.Algebra.Order.Monoid.OrderDual
 import Mathlib.Algebra.Order.Monoid.WithZero.Basic
-import Mathlib.Data.Nat.Cast.Defs
 import Mathlib.Algebra.Order.ZeroLEOne
-import Mathlib.Algebra.CharZero.Defs
+import Mathlib.Data.Nat.Cast.Defs
 
 #align_import algebra.order.monoid.with_top from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"

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

Renames:

CanonicallyOrderedMonoid -> CanonicallyOrderedCommMonoid

CanonicallyOrderedAddMonoid -> CanonicallyOrderedAddCommMonoid

CanonicallyLinearOrderedMonoid -> CanonicallyLinearOrderedCommMonoid

CanonicallyLinearOrderedAddMonoid -> CanonicallyLinearOrderedAddCommMonoid

f3bc24c3

Diff

@@ -383,8 +383,8 @@ instance existsAddOfLE [LE α] [Add α] [ExistsAddOfLE α] : ExistsAddOfLE (With
       exact ⟨c, rfl⟩
     | ⊤, (b : α) => fun h => (not_top_le_coe _ h).elim⟩
 
-instance canonicallyOrderedAddMonoid [CanonicallyOrderedAddMonoid α] :
-    CanonicallyOrderedAddMonoid (WithTop α) :=
+instance canonicallyOrderedAddCommMonoid [CanonicallyOrderedAddCommMonoid α] :
+    CanonicallyOrderedAddCommMonoid (WithTop α) :=
   { WithTop.orderBot, WithTop.orderedAddCommMonoid, WithTop.existsAddOfLE with
     le_self_add := fun a b =>
       match a, b with
@@ -393,8 +393,9 @@ instance canonicallyOrderedAddMonoid [CanonicallyOrderedAddMonoid α] :
       | (a : α), (b : α) => WithTop.coe_le_coe.2 le_self_add
       | ⊤, (b : α) => le_rfl }
 
-instance [CanonicallyLinearOrderedAddMonoid α] : CanonicallyLinearOrderedAddMonoid (WithTop α) :=
-  { WithTop.canonicallyOrderedAddMonoid, WithTop.linearOrder with }
+instance [CanonicallyLinearOrderedAddCommMonoid α] :
+    CanonicallyLinearOrderedAddCommMonoid (WithTop α) :=
+  { WithTop.canonicallyOrderedAddCommMonoid, WithTop.linearOrder with }
 
 @[simp, norm_cast]
 theorem coe_nat [AddMonoidWithOne α] (n : ℕ) : ((n : α) : WithTop α) = n :=

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

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

260cb506

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Mathlib.Algebra.Hom.Group
+import Mathlib.Algebra.Hom.Group.Defs
 import Mathlib.Algebra.Order.Monoid.OrderDual
 import Mathlib.Algebra.Order.Monoid.WithZero.Basic
 import Mathlib.Data.Nat.Cast.Defs

feat: WithTop.charZero (#6992)

Also WithBot.charZero

844436b8

Diff

@@ -8,6 +8,7 @@ import Mathlib.Algebra.Order.Monoid.OrderDual
 import Mathlib.Algebra.Order.Monoid.WithZero.Basic
 import Mathlib.Data.Nat.Cast.Defs
 import Mathlib.Algebra.Order.ZeroLEOne
+import Mathlib.Algebra.CharZero.Defs
 
 #align_import algebra.order.monoid.with_top from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
 
@@ -351,6 +352,10 @@ instance addMonoidWithOne [AddMonoidWithOne α] : AddMonoidWithOne (WithTop α)
       rw [Nat.cast_add_one, WithTop.coe_add, WithTop.coe_one]
   }
 
+instance charZero [AddMonoidWithOne α] [CharZero α] : CharZero (WithTop α) :=
+  { cast_injective := Function.Injective.comp (f := Nat.cast (R := α))
+      (fun _ _ => WithTop.coe_eq_coe.1) Nat.cast_injective}
+
 instance addCommMonoidWithOne [AddCommMonoidWithOne α] : AddCommMonoidWithOne (WithTop α) :=
   { WithTop.addMonoidWithOne, WithTop.addCommMonoid with }
 
@@ -490,6 +495,9 @@ instance addCommMonoid [AddCommMonoid α] : AddCommMonoid (WithBot α) :=
 instance addMonoidWithOne [AddMonoidWithOne α] : AddMonoidWithOne (WithBot α) :=
   WithTop.addMonoidWithOne
 
+instance charZero [AddMonoidWithOne α] [CharZero α] : CharZero (WithBot α) :=
+  WithTop.charZero
+
 instance addCommMonoidWithOne [AddCommMonoidWithOne α] : AddCommMonoidWithOne (WithBot α) :=
   WithTop.addCommMonoidWithOne

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

@@ -436,7 +436,7 @@ theorem zero_lt_coe [OrderedAddCommMonoid α] (a : α) : (0 : WithTop α) < a 
 /-- A version of `WithTop.map` for `OneHom`s. -/
 @[to_additive (attr := simps (config := { fullyApplied := false }))
   "A version of `WithTop.map` for `ZeroHom`s"]
-protected def _root_.OneHom.withTopMap {M N : Type _} [One M] [One N] (f : OneHom M N) :
+protected def _root_.OneHom.withTopMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
     OneHom (WithTop M) (WithTop N) where
   toFun := WithTop.map f
   map_one' := by rw [WithTop.map_one, map_one, coe_one]
@@ -446,7 +446,7 @@ protected def _root_.OneHom.withTopMap {M N : Type _} [One M] [One N] (f : OneHo
 
 /-- A version of `WithTop.map` for `AddHom`s. -/
 @[simps (config := { fullyApplied := false })]
-protected def _root_.AddHom.withTopMap {M N : Type _} [Add M] [Add N] (f : AddHom M N) :
+protected def _root_.AddHom.withTopMap {M N : Type*} [Add M] [Add N] (f : AddHom M N) :
     AddHom (WithTop M) (WithTop N) where
   toFun := WithTop.map f
   map_add' := WithTop.map_add f
@@ -455,7 +455,7 @@ protected def _root_.AddHom.withTopMap {M N : Type _} [Add M] [Add N] (f : AddHo
 
 /-- A version of `WithTop.map` for `AddMonoidHom`s. -/
 @[simps (config := { fullyApplied := false })]
-protected def _root_.AddMonoidHom.withTopMap {M N : Type _} [AddZeroClass M] [AddZeroClass N]
+protected def _root_.AddMonoidHom.withTopMap {M N : Type*} [AddZeroClass M] [AddZeroClass N]
     (f : M →+ N) : WithTop M →+ WithTop N :=
   { ZeroHom.withTopMap f.toZeroHom, AddHom.withTopMap f.toAddHom with toFun := WithTop.map f }
 #align add_monoid_hom.with_top_map AddMonoidHom.withTopMap
@@ -653,7 +653,7 @@ protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : With
 /-- A version of `WithBot.map` for `OneHom`s. -/
 @[to_additive (attr := simps (config := { fullyApplied := false }))
   "A version of `WithBot.map` for `ZeroHom`s"]
-protected def _root_.OneHom.withBotMap {M N : Type _} [One M] [One N] (f : OneHom M N) :
+protected def _root_.OneHom.withBotMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
     OneHom (WithBot M) (WithBot N) where
   toFun := WithBot.map f
   map_one' := by rw [WithBot.map_one, map_one, coe_one]
@@ -664,7 +664,7 @@ protected def _root_.OneHom.withBotMap {M N : Type _} [One M] [One N] (f : OneHo
 
 /-- A version of `WithBot.map` for `AddHom`s. -/
 @[simps (config := { fullyApplied := false })]
-protected def _root_.AddHom.withBotMap {M N : Type _} [Add M] [Add N] (f : AddHom M N) :
+protected def _root_.AddHom.withBotMap {M N : Type*} [Add M] [Add N] (f : AddHom M N) :
     AddHom (WithBot M) (WithBot N) where
   toFun := WithBot.map f
   map_add' := WithBot.map_add f
@@ -673,7 +673,7 @@ protected def _root_.AddHom.withBotMap {M N : Type _} [Add M] [Add N] (f : AddHo
 
 /-- A version of `WithBot.map` for `AddMonoidHom`s. -/
 @[simps (config := { fullyApplied := false })]
-protected def _root_.AddMonoidHom.withBotMap {M N : Type _} [AddZeroClass M] [AddZeroClass N]
+protected def _root_.AddMonoidHom.withBotMap {M N : Type*} [AddZeroClass M] [AddZeroClass N]
     (f : M →+ N) : WithBot M →+ WithBot N :=
   { ZeroHom.withBotMap f.toZeroHom, AddHom.withBotMap f.toAddHom with toFun := WithBot.map f }
 #align add_monoid_hom.with_bot_map AddMonoidHom.withBotMap

feat(Algebra/Order/Monoid/WithTop): missing WithBot lemmas in #5837 (#6154)

Missing WithBot lemmas in #5837

0d7ac76d

Diff

@@ -187,8 +187,8 @@ theorem add_right_cancel_iff [IsRightCancelAdd α] (ha : a ≠ ⊤) : b + a = c
   simp_rw [←WithTop.coe_add, eq_comm, WithTop.add_eq_coe, coe_eq_coe, exists_and_left,
     exists_eq_left, add_left_inj, exists_eq_right, eq_comm]
 
-theorem add_right_cancel [IsRightCancelAdd α] (ha : a ≠ ⊤) (hle : b + a = c + a) : b = c :=
-  (WithTop.add_right_cancel_iff ha).1 hle
+theorem add_right_cancel [IsRightCancelAdd α] (ha : a ≠ ⊤) (h : b + a = c + a) : b = c :=
+  (WithTop.add_right_cancel_iff ha).1 h
 
 theorem add_left_cancel_iff [IsLeftCancelAdd α] (ha : a ≠ ⊤) : a + b = a + c ↔ b = c := by
   lift a to α using ha
@@ -198,8 +198,8 @@ theorem add_left_cancel_iff [IsLeftCancelAdd α] (ha : a ≠ ⊤) : a + b = a +
   simp_rw [←WithTop.coe_add, eq_comm, WithTop.add_eq_coe, eq_comm, coe_eq_coe,
     exists_and_left, exists_eq_left', add_right_inj, exists_eq_right']
 
-theorem add_left_cancel [IsLeftCancelAdd α] (ha : a ≠ ⊤) (hle : a + b = a + c) : b = c :=
-  (WithTop.add_left_cancel_iff ha).1 hle
+theorem add_left_cancel [IsLeftCancelAdd α] (ha : a ≠ ⊤) (h : a + b = a + c) : b = c :=
+  (WithTop.add_left_cancel_iff ha).1 h
 
 instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (· + ·) (· ≤ ·) :=
@@ -631,6 +631,18 @@ theorem coe_add_eq_bot_iff : ↑x + b = ⊥ ↔ b = ⊥ :=
   WithTop.coe_add_eq_top_iff
 #align with_bot.coe_add_eq_bot_iff WithBot.coe_add_eq_bot_iff
 
+theorem add_right_cancel_iff [IsRightCancelAdd α] (ha : a ≠ ⊥) : b + a = c + a ↔ b = c :=
+  WithTop.add_right_cancel_iff ha
+
+theorem add_right_cancel [IsRightCancelAdd α] (ha : a ≠ ⊥) (h : b + a = c + a) : b = c :=
+  WithTop.add_right_cancel ha h
+
+theorem add_left_cancel_iff [IsLeftCancelAdd α] (ha : a ≠ ⊥) : a + b = a + c ↔ b = c :=
+  WithTop.add_left_cancel_iff ha
+
+theorem add_left_cancel [IsLeftCancelAdd α] (ha : a ≠ ⊥) (h : a + b = a + c) : b = c :=
+  WithTop.add_left_cancel ha h
+
 -- There is no `WithBot.map_mul_of_mulHom`, since `WithBot` does not have a multiplication.
 @[simp]
 protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : WithBot α) :

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

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

I propose deleting them.

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

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

e8318a88

Diff

@@ -2,7 +2,6 @@
 Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
-Ported by: Jon Eugster
 -/
 import Mathlib.Algebra.Hom.Group
 import Mathlib.Algebra.Order.Monoid.OrderDual

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

depends on: #5966

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

89aa3a3b

Diff

@@ -3,11 +3,6 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 Ported by: Jon Eugster
-
-! This file was ported from Lean 3 source module algebra.order.monoid.with_top
-! leanprover-community/mathlib commit 0111834459f5d7400215223ea95ae38a1265a907
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Hom.Group
 import Mathlib.Algebra.Order.Monoid.OrderDual
@@ -15,6 +10,8 @@ import Mathlib.Algebra.Order.Monoid.WithZero.Basic
 import Mathlib.Data.Nat.Cast.Defs
 import Mathlib.Algebra.Order.ZeroLEOne
 
+#align_import algebra.order.monoid.with_top from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
+
 /-! # Adjoining top/bottom elements to ordered monoids.
 -/

feat: add cancel lemmas in WithTop (#5837)

This PR adds four lemmas that allow cancelling addition in WithTop α when the term being cancelled is not ⊤. They complement the existing le/lt versions.

e7b874fd

Diff

@@ -183,6 +183,28 @@ theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ := by
   induction y using WithTop.recTopCoe <;> simp [← coe_add]
 #align with_top.coe_add_eq_top_iff WithTop.coe_add_eq_top_iff
 
+theorem add_right_cancel_iff [IsRightCancelAdd α] (ha : a ≠ ⊤) : b + a = c + a ↔ b = c := by
+  lift a to α using ha
+  obtain rfl | hb := (eq_or_ne b ⊤)
+  · rw [top_add, eq_comm, WithTop.add_coe_eq_top_iff, eq_comm]
+  lift b to α using hb
+  simp_rw [←WithTop.coe_add, eq_comm, WithTop.add_eq_coe, coe_eq_coe, exists_and_left,
+    exists_eq_left, add_left_inj, exists_eq_right, eq_comm]
+
+theorem add_right_cancel [IsRightCancelAdd α] (ha : a ≠ ⊤) (hle : b + a = c + a) : b = c :=
+  (WithTop.add_right_cancel_iff ha).1 hle
+
+theorem add_left_cancel_iff [IsLeftCancelAdd α] (ha : a ≠ ⊤) : a + b = a + c ↔ b = c := by
+  lift a to α using ha
+  obtain rfl | hb := (eq_or_ne b ⊤)
+  · rw [add_top, eq_comm, WithTop.coe_add_eq_top_iff, eq_comm]
+  lift b to α using hb
+  simp_rw [←WithTop.coe_add, eq_comm, WithTop.add_eq_coe, eq_comm, coe_eq_coe,
+    exists_and_left, exists_eq_left', add_right_inj, exists_eq_right']
+
+theorem add_left_cancel [IsLeftCancelAdd α] (ha : a ≠ ⊤) (hle : a + b = a + c) : b = c :=
+  (WithTop.add_left_cancel_iff ha).1 hle
+
 instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithTop α) (WithTop α) (· + ·) (· ≤ ·) :=
   ⟨fun a b c h => by

chore: clean up spacing around at and goals (#5387)

Changes are of the form

some_tactic at h⊢ -> some_tactic at h ⊢
some_tactic at h -> some_tactic at h

2a870323

Diff

@@ -342,7 +342,7 @@ instance orderedAddCommMonoid [OrderedAddCommMonoid α] : OrderedAddCommMonoid (
       rintro a b h (_ | c); · simp [none_eq_top]
       rcases b with (_ | b); · simp [none_eq_top]
       rcases le_coe_iff.1 h with ⟨a, rfl, _⟩
-      simp only [some_eq_coe, ← coe_add, coe_le_coe] at h⊢
+      simp only [some_eq_coe, ← coe_add, coe_le_coe] at h ⊢
       exact add_le_add_left h c }
 
 instance linearOrderedAddCommMonoidWithTop [LinearOrderedAddCommMonoid α] :

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

@@ -227,7 +227,6 @@ protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· +
     · exact (not_top_le_coe _ h).elim
     · simp only [← coe_add, coe_le_coe] at h ⊢
       exact le_of_add_le_add_left h
-
 #align with_top.le_of_add_le_add_left WithTop.le_of_add_le_add_left
 
 protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]

feat: forward-port leanprover-community/mathlib#18582 (#2929)

16edf724

Diff

@@ -5,7 +5,7 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 Ported by: Jon Eugster
 
 ! This file was ported from Lean 3 source module algebra.order.monoid.with_top
-! leanprover-community/mathlib commit afdb4fa3b32d41106a4a09b371ce549ad7958abd
+! leanprover-community/mathlib commit 0111834459f5d7400215223ea95ae38a1265a907
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,7 +15,8 @@ import Mathlib.Algebra.Order.Monoid.WithZero.Basic
 import Mathlib.Data.Nat.Cast.Defs
 import Mathlib.Algebra.Order.ZeroLEOne
 
-/-! # Adjoining top/bottom elements to ordered monoids. -/
+/-! # Adjoining top/bottom elements to ordered monoids.
+-/
 
 universe u v
 
@@ -47,6 +48,18 @@ theorem coe_eq_one {a : α} : (a : WithTop α) = 1 ↔ a = 1 :=
 #align with_top.coe_eq_one WithTop.coe_eq_one
 #align with_top.coe_eq_zero WithTop.coe_eq_zero
 
+@[to_additive (attr := simp)]
+theorem untop_one : (1 : WithTop α).untop coe_ne_top = 1 :=
+  rfl
+#align with_top.untop_one WithTop.untop_one
+#align with_top.untop_zero WithTop.untop_zero
+
+@[to_additive (attr := simp)]
+theorem untop_one' (d : α) : (1 : WithTop α).untop' d = 1 :=
+  rfl
+#align with_top.untop_one' WithTop.untop_one'
+#align with_top.untop_zero' WithTop.untop_zero'
+
 @[to_additive (attr := simp, norm_cast) coe_nonneg]
 theorem one_le_coe [LE α] {a : α} : 1 ≤ (a : WithTop α) ↔ 1 ≤ a :=
   coe_le_coe
@@ -480,6 +493,18 @@ theorem coe_eq_one [One α] {a : α} : (a : WithBot α) = 1 ↔ a = 1 :=
 #align with_bot.coe_eq_one WithBot.coe_eq_one
 #align with_bot.coe_eq_zero WithBot.coe_eq_zero
 
+@[to_additive (attr := simp)]
+theorem unbot_one [One α] : (1 : WithBot α).unbot coe_ne_bot = 1 :=
+  rfl
+#align with_bot.unbot_one WithBot.unbot_one
+#align with_bot.unbot_zero WithBot.unbot_zero
+
+@[to_additive (attr := simp)]
+theorem unbot_one' [One α] (d : α) : (1 : WithBot α).unbot' d = 1 :=
+  rfl
+#align with_bot.unbot_one' WithBot.unbot_one'
+#align with_bot.unbot_zero' WithBot.unbot_zero'
+
 @[to_additive (attr := simp, norm_cast) coe_nonneg]
 theorem one_le_coe [One α] [LE α] {a : α} : 1 ≤ (a : WithBot α) ↔ 1 ≤ a :=
   coe_le_coe

feat: add/generalize lemmas about WithTop/WithBot (#2406)

Some of these lemmas are generalized from ENNReal while porting Data.Real.ENNReal. Backported to Mathlib 3 in leanprover-community/mathlib#18487, now forward-porting back to Mathlib 4. Also forward-porting leanprover-community/mathlib#18391

357d16b1

Diff

@@ -5,7 +5,7 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 Ported by: Jon Eugster
 
 ! This file was ported from Lean 3 source module algebra.order.monoid.with_top
-! leanprover-community/mathlib commit e7e2ba8aa216a5833b5ed85a93317263711a36b5
+! leanprover-community/mathlib commit afdb4fa3b32d41106a4a09b371ce549ad7958abd
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -146,8 +146,8 @@ theorem add_ne_top : a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ :=
   add_eq_top.not.trans not_or
 #align with_top.add_ne_top WithTop.add_ne_top
 
-theorem add_lt_top [PartialOrder α] {a b : WithTop α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ := by
-  simp_rw [lt_top_iff_ne_top, add_ne_top]
+theorem add_lt_top [LT α] {a b : WithTop α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ := by
+  simp_rw [WithTop.lt_top_iff_ne_top, add_ne_top]
 #align with_top.add_lt_top WithTop.add_lt_top
 
 theorem add_eq_coe :
@@ -569,7 +569,7 @@ theorem add_ne_bot : a + b ≠ ⊥ ↔ a ≠ ⊥ ∧ b ≠ ⊥ :=
   WithTop.add_ne_top
 #align with_bot.add_ne_bot WithBot.add_ne_bot
 
-theorem bot_lt_add [PartialOrder α] {a b : WithBot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b :=
+theorem bot_lt_add [LT α] {a b : WithBot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b :=
   @WithTop.add_lt_top αᵒᵈ _ _ _ _
 #align with_bot.bot_lt_add WithBot.bot_lt_add

e7e2ba8a

chore: update SHA of already forward-ported files (#2181)

Update some SHAs of files that changed in mathlib3.

These 17 files need mainly only updated SHA as they've been only touched by backports or already have been forward-ported.

The relevant changes are:

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

88c789ef

Diff

@@ -5,7 +5,7 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 Ported by: Jon Eugster
 
 ! This file was ported from Lean 3 source module algebra.order.monoid.with_top
-! leanprover-community/mathlib commit 2258b40dacd2942571c8ce136215350c702dc78f
+! leanprover-community/mathlib commit e7e2ba8aa216a5833b5ed85a93317263711a36b5
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

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

adaaf293

Diff

@@ -404,8 +404,8 @@ theorem zero_lt_coe [OrderedAddCommMonoid α] (a : α) : (0 : WithTop α) < a 
 #align with_top.zero_lt_coe WithTop.zero_lt_coe
 
 /-- A version of `WithTop.map` for `OneHom`s. -/
-@[to_additive "A version of `WithTop.map` for `ZeroHom`s",
-  simps (config := { fullyApplied := false })]
+@[to_additive (attr := simps (config := { fullyApplied := false }))
+  "A version of `WithTop.map` for `ZeroHom`s"]
 protected def _root_.OneHom.withTopMap {M N : Type _} [One M] [One N] (f : OneHom M N) :
     OneHom (WithTop M) (WithTop N) where
   toFun := WithTop.map f
@@ -597,8 +597,8 @@ protected theorem map_add {F} [Add β] [AddHomClass F α β] (f : F) (a b : With
 #align with_bot.map_add WithBot.map_add
 
 /-- A version of `WithBot.map` for `OneHom`s. -/
-@[to_additive "A version of `WithBot.map` for `ZeroHom`s",
-  simps (config := { fullyApplied := false })]
+@[to_additive (attr := simps (config := { fullyApplied := false }))
+  "A version of `WithBot.map` for `ZeroHom`s"]
 protected def _root_.OneHom.withBotMap {M N : Type _} [One M] [One N] (f : OneHom M N) :
     OneHom (WithBot M) (WithBot N) where
   toFun := WithBot.map f
@@ -606,6 +606,7 @@ protected def _root_.OneHom.withBotMap {M N : Type _} [One M] [One N] (f : OneHo
 #align one_hom.with_bot_map OneHom.withBotMap
 #align zero_hom.with_bot_map ZeroHom.withBotMap
 #align one_hom.with_bot_map_apply OneHom.withBotMap_apply
+#align zero_hom.with_bot_map_apply ZeroHom.withBotMap_apply
 
 /-- A version of `WithBot.map` for `AddHom`s. -/
 @[simps (config := { fullyApplied := false })]

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

@@ -51,11 +51,13 @@ theorem coe_eq_one {a : α} : (a : WithTop α) = 1 ↔ a = 1 :=
 theorem one_le_coe [LE α] {a : α} : 1 ≤ (a : WithTop α) ↔ 1 ≤ a :=
   coe_le_coe
 #align with_top.one_le_coe WithTop.one_le_coe
+#align with_top.coe_nonneg WithTop.coe_nonneg
 
 @[to_additive (attr := simp, norm_cast) coe_le_zero]
 theorem coe_le_one [LE α] {a : α} : (a : WithTop α) ≤ 1 ↔ a ≤ 1 :=
   coe_le_coe
 #align with_top.coe_le_one WithTop.coe_le_one
+#align with_top.coe_le_zero WithTop.coe_le_zero
 
 @[to_additive (attr := simp, norm_cast) coe_pos]
 theorem one_lt_coe [LT α] {a : α} : 1 < (a : WithTop α) ↔ 1 < a :=
@@ -410,6 +412,7 @@ protected def _root_.OneHom.withTopMap {M N : Type _} [One M] [One N] (f : OneHo
   map_one' := by rw [WithTop.map_one, map_one, coe_one]
 #align one_hom.with_top_map OneHom.withTopMap
 #align zero_hom.with_top_map ZeroHom.withTopMap
+#align one_hom.with_top_map_apply OneHom.withTopMap_apply
 
 /-- A version of `WithTop.map` for `AddHom`s. -/
 @[simps (config := { fullyApplied := false })]
@@ -418,6 +421,7 @@ protected def _root_.AddHom.withTopMap {M N : Type _} [Add M] [Add N] (f : AddHo
   toFun := WithTop.map f
   map_add' := WithTop.map_add f
 #align add_hom.with_top_map AddHom.withTopMap
+#align add_hom.with_top_map_apply AddHom.withTopMap_apply
 
 /-- A version of `WithTop.map` for `AddMonoidHom`s. -/
 @[simps (config := { fullyApplied := false })]
@@ -425,6 +429,7 @@ protected def _root_.AddMonoidHom.withTopMap {M N : Type _} [AddZeroClass M] [Ad
     (f : M →+ N) : WithTop M →+ WithTop N :=
   { ZeroHom.withTopMap f.toZeroHom, AddHom.withTopMap f.toAddHom with toFun := WithTop.map f }
 #align add_monoid_hom.with_top_map AddMonoidHom.withTopMap
+#align add_monoid_hom.with_top_map_apply AddMonoidHom.withTopMap_apply
 
 end WithTop
 
@@ -479,11 +484,13 @@ theorem coe_eq_one [One α] {a : α} : (a : WithBot α) = 1 ↔ a = 1 :=
 theorem one_le_coe [One α] [LE α] {a : α} : 1 ≤ (a : WithBot α) ↔ 1 ≤ a :=
   coe_le_coe
 #align with_bot.one_le_coe WithBot.one_le_coe
+#align with_bot.coe_nonneg WithBot.coe_nonneg
 
 @[to_additive (attr := simp, norm_cast) coe_le_zero]
 theorem coe_le_one [One α] [LE α] {a : α} : (a : WithBot α) ≤ 1 ↔ a ≤ 1 :=
   coe_le_coe
 #align with_bot.coe_le_one WithBot.coe_le_one
+#align with_bot.coe_le_zero WithBot.coe_le_zero
 
 @[to_additive (attr := simp, norm_cast) coe_pos]
 theorem one_lt_coe [One α] [LT α] {a : α} : 1 < (a : WithBot α) ↔ 1 < a :=
@@ -598,6 +605,7 @@ protected def _root_.OneHom.withBotMap {M N : Type _} [One M] [One N] (f : OneHo
   map_one' := by rw [WithBot.map_one, map_one, coe_one]
 #align one_hom.with_bot_map OneHom.withBotMap
 #align zero_hom.with_bot_map ZeroHom.withBotMap
+#align one_hom.with_bot_map_apply OneHom.withBotMap_apply
 
 /-- A version of `WithBot.map` for `AddHom`s. -/
 @[simps (config := { fullyApplied := false })]
@@ -606,6 +614,7 @@ protected def _root_.AddHom.withBotMap {M N : Type _} [Add M] [Add N] (f : AddHo
   toFun := WithBot.map f
   map_add' := WithBot.map_add f
 #align add_hom.with_bot_map AddHom.withBotMap
+#align add_hom.with_bot_map_apply AddHom.withBotMap_apply
 
 /-- A version of `WithBot.map` for `AddMonoidHom`s. -/
 @[simps (config := { fullyApplied := false })]
@@ -613,6 +622,7 @@ protected def _root_.AddMonoidHom.withBotMap {M N : Type _} [AddZeroClass M] [Ad
     (f : M →+ N) : WithBot M →+ WithBot N :=
   { ZeroHom.withBotMap f.toZeroHom, AddHom.withBotMap f.toAddHom with toFun := WithBot.map f }
 #align add_monoid_hom.with_bot_map AddMonoidHom.withBotMap
+#align add_monoid_hom.with_bot_map_apply AddMonoidHom.withBotMap_apply
 
 variable [Preorder α]

Refactor: use Option.map₂ (#1439)

This is a forward-port of leanprover-community/mathlib#18081

da1e6541

Diff

@@ -103,7 +103,7 @@ section Add
 variable [Add α] {a b c d : WithTop α} {x y : α}
 
 instance add : Add (WithTop α) :=
-  ⟨fun o₁ o₂ => o₁.bind fun a => o₂.map <| (· + ·) a⟩
+  ⟨Option.map₂ (· + ·)⟩
 #align with_top.has_add WithTop.add
 
 @[norm_cast]
@@ -291,46 +291,16 @@ end Add
 
 instance addSemigroup [AddSemigroup α] : AddSemigroup (WithTop α) :=
   { WithTop.add with
-    add_assoc := by
-      refine' WithTop.recTopCoe _ _ <;> try intro
-      · simp only [top_add, forall_const]
-      · refine' WithTop.recTopCoe _ _
-        · simp only [add_top, top_add, forall_const]
-        · intro
-          refine' WithTop.recTopCoe _ _
-          · simp only [coe_add, add_top]
-          · intro
-            simp only [← WithTop.coe_add, add_assoc] }
--- Porting notes: mathlib3 proof was:
---   repeat { refine with_top.rec_top_coe _ _; try { intro }};
---   simp [←with_top.coe_add, add_assoc]
+    add_assoc := fun _ _ _ => Option.map₂_assoc add_assoc }
 
 instance addCommSemigroup [AddCommSemigroup α] : AddCommSemigroup (WithTop α) :=
   { WithTop.addSemigroup with
-    add_comm := by
-      refine' WithTop.recTopCoe _ _ <;> try intro
-      · rw [top_add, add_top]
-      · refine' WithTop.recTopCoe _ _
-        · rw [add_top, top_add]
-        · intro
-          simp only [← WithTop.coe_add, add_comm] }
--- Porting notes: mathlib3 proof was:
---   repeat { refine with_top.rec_top_coe _ _; try { intro }};
---   simp [←with_top.coe_add, add_comm]
-
+    add_comm := fun _ _ => Option.map₂_comm add_comm }
 
 instance addZeroClass [AddZeroClass α] : AddZeroClass (WithTop α) :=
   { WithTop.zero, WithTop.add with
-    zero_add := by
-      refine' WithTop.recTopCoe _ _
-      · simp
-      · intro
-        rw [← WithTop.coe_zero, ← WithTop.coe_add, zero_add],
-    add_zero := by
-      refine' WithTop.recTopCoe _ _
-      · simp
-      · intro
-        rw [← WithTop.coe_zero, ← WithTop.coe_add, add_zero] }
+    zero_add := Option.map₂_left_identity zero_add
+    add_zero := Option.map₂_right_identity add_zero }
 
 instance addMonoid [AddMonoid α] : AddMonoid (WithTop α) :=
   { WithTop.addSemigroup, WithTop.addZeroClass with }

feat: ring covariance & ordered ring typeclasses for WithBot (#1508)

mathlib3 PR: https://github.com/leanprover-community/mathlib/pull/18149

Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

98bc5f26

Diff

@@ -47,6 +47,16 @@ theorem coe_eq_one {a : α} : (a : WithTop α) = 1 ↔ a = 1 :=
 #align with_top.coe_eq_one WithTop.coe_eq_one
 #align with_top.coe_eq_zero WithTop.coe_eq_zero
 
+@[to_additive (attr := simp, norm_cast) coe_nonneg]
+theorem one_le_coe [LE α] {a : α} : 1 ≤ (a : WithTop α) ↔ 1 ≤ a :=
+  coe_le_coe
+#align with_top.one_le_coe WithTop.one_le_coe
+
+@[to_additive (attr := simp, norm_cast) coe_le_zero]
+theorem coe_le_one [LE α] {a : α} : (a : WithTop α) ≤ 1 ↔ a ≤ 1 :=
+  coe_le_coe
+#align with_top.coe_le_one WithTop.coe_le_one
+
 @[to_additive (attr := simp, norm_cast) coe_pos]
 theorem one_lt_coe [LT α] {a : α} : 1 < (a : WithTop α) ↔ 1 < a :=
   coe_lt_coe
@@ -495,19 +505,29 @@ theorem coe_eq_one [One α] {a : α} : (a : WithBot α) = 1 ↔ a = 1 :=
 #align with_bot.coe_eq_one WithBot.coe_eq_one
 #align with_bot.coe_eq_zero WithBot.coe_eq_zero
 
-@[to_additive (attr := norm_cast) coe_pos]
+@[to_additive (attr := simp, norm_cast) coe_nonneg]
+theorem one_le_coe [One α] [LE α] {a : α} : 1 ≤ (a : WithBot α) ↔ 1 ≤ a :=
+  coe_le_coe
+#align with_bot.one_le_coe WithBot.one_le_coe
+
+@[to_additive (attr := simp, norm_cast) coe_le_zero]
+theorem coe_le_one [One α] [LE α] {a : α} : (a : WithBot α) ≤ 1 ↔ a ≤ 1 :=
+  coe_le_coe
+#align with_bot.coe_le_one WithBot.coe_le_one
+
+@[to_additive (attr := simp, norm_cast) coe_pos]
 theorem one_lt_coe [One α] [LT α] {a : α} : 1 < (a : WithBot α) ↔ 1 < a :=
   coe_lt_coe
 #align with_bot.one_lt_coe WithBot.one_lt_coe
 #align with_bot.coe_pos WithBot.coe_pos
 
-@[to_additive (attr := norm_cast) coe_lt_zero]
+@[to_additive (attr := simp, norm_cast) coe_lt_zero]
 theorem coe_lt_one [One α] [LT α] {a : α} : (a : WithBot α) < 1 ↔ a < 1 :=
   coe_lt_coe
 #align with_bot.coe_lt_one WithBot.coe_lt_one
 #align with_bot.coe_lt_zero WithBot.coe_lt_zero
 
-@[to_additive]
+@[to_additive (attr := simp)]
 protected theorem map_one {β} [One α] (f : α → β) : (1 : WithBot α).map f = (f 1 : WithBot β) :=
   rfl
 #align with_bot.map_one WithBot.map_one

chore: add #align statements for to_additive decls (#1816)

Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

ed378238

Diff

@@ -33,46 +33,55 @@ variable [One α]
 instance one : One (WithTop α) :=
   ⟨(1 : α)⟩
 #align with_top.has_one WithTop.one
+#align with_top.has_zero WithTop.zero
 
 @[to_additive (attr := simp, norm_cast)]
 theorem coe_one : ((1 : α) : WithTop α) = 1 :=
   rfl
 #align with_top.coe_one WithTop.coe_one
+#align with_top.coe_zero WithTop.coe_zero
 
 @[to_additive (attr := simp, norm_cast)]
 theorem coe_eq_one {a : α} : (a : WithTop α) = 1 ↔ a = 1 :=
   coe_eq_coe
 #align with_top.coe_eq_one WithTop.coe_eq_one
+#align with_top.coe_eq_zero WithTop.coe_eq_zero
 
 @[to_additive (attr := simp, norm_cast) coe_pos]
 theorem one_lt_coe [LT α] {a : α} : 1 < (a : WithTop α) ↔ 1 < a :=
   coe_lt_coe
 #align with_top.one_lt_coe WithTop.one_lt_coe
+#align with_top.coe_pos WithTop.coe_pos
 
 @[to_additive (attr := simp, norm_cast) coe_lt_zero]
 theorem coe_lt_one [LT α] {a : α} : (a : WithTop α) < 1 ↔ a < 1 :=
   coe_lt_coe
 #align with_top.coe_lt_one WithTop.coe_lt_one
+#align with_top.coe_lt_zero WithTop.coe_lt_zero
 
 @[to_additive (attr := simp)]
 protected theorem map_one {β} (f : α → β) : (1 : WithTop α).map f = (f 1 : WithTop β) :=
   rfl
 #align with_top.map_one WithTop.map_one
+#align with_top.map_zero WithTop.map_zero
 
 @[to_additive (attr := simp, norm_cast)]
 theorem one_eq_coe {a : α} : 1 = (a : WithTop α) ↔ a = 1 :=
   Trans.trans eq_comm coe_eq_one
 #align with_top.one_eq_coe WithTop.one_eq_coe
+#align with_top.zero_eq_coe WithTop.zero_eq_coe
 
 @[to_additive (attr := simp)]
 theorem top_ne_one : ⊤ ≠ (1 : WithTop α) :=
   fun.
 #align with_top.top_ne_one WithTop.top_ne_one
+#align with_top.top_ne_zero WithTop.top_ne_zero
 
 @[to_additive (attr := simp)]
 theorem one_ne_top : (1 : WithTop α) ≠ ⊤ :=
   fun.
 #align with_top.one_ne_top WithTop.one_ne_top
+#align with_top.zero_ne_top WithTop.zero_ne_top
 
 instance zeroLEOneClass [Zero α] [LE α] [ZeroLEOneClass α] : ZeroLEOneClass (WithTop α) :=
   ⟨some_le_some.2 zero_le_one⟩
@@ -420,6 +429,7 @@ protected def _root_.OneHom.withTopMap {M N : Type _} [One M] [One N] (f : OneHo
   toFun := WithTop.map f
   map_one' := by rw [WithTop.map_one, map_one, coe_one]
 #align one_hom.with_top_map OneHom.withTopMap
+#align zero_hom.with_top_map ZeroHom.withTopMap
 
 /-- A version of `WithTop.map` for `AddHom`s. -/
 @[simps (config := { fullyApplied := false })]
@@ -476,27 +486,32 @@ instance zeroLEOneClass [Zero α] [One α] [LE α] [ZeroLEOneClass α] : ZeroLEO
 theorem coe_one [One α] : ((1 : α) : WithBot α) = 1 :=
   rfl
 #align with_bot.coe_one WithBot.coe_one
+#align with_bot.coe_zero WithBot.coe_zero
 
 -- `by norm_cast` proves this lemma, so I did not tag it with `norm_cast`
 @[to_additive]
 theorem coe_eq_one [One α] {a : α} : (a : WithBot α) = 1 ↔ a = 1 :=
   WithTop.coe_eq_one
 #align with_bot.coe_eq_one WithBot.coe_eq_one
+#align with_bot.coe_eq_zero WithBot.coe_eq_zero
 
 @[to_additive (attr := norm_cast) coe_pos]
 theorem one_lt_coe [One α] [LT α] {a : α} : 1 < (a : WithBot α) ↔ 1 < a :=
   coe_lt_coe
 #align with_bot.one_lt_coe WithBot.one_lt_coe
+#align with_bot.coe_pos WithBot.coe_pos
 
 @[to_additive (attr := norm_cast) coe_lt_zero]
 theorem coe_lt_one [One α] [LT α] {a : α} : (a : WithBot α) < 1 ↔ a < 1 :=
   coe_lt_coe
 #align with_bot.coe_lt_one WithBot.coe_lt_one
+#align with_bot.coe_lt_zero WithBot.coe_lt_zero
 
 @[to_additive]
 protected theorem map_one {β} [One α] (f : α → β) : (1 : WithBot α).map f = (f 1 : WithBot β) :=
   rfl
 #align with_bot.map_one WithBot.map_one
+#align with_bot.map_zero WithBot.map_zero
 
 @[norm_cast]
 theorem coe_nat [AddMonoidWithOne α] (n : ℕ) : ((n : α) : WithBot α) = n :=
@@ -592,6 +607,7 @@ protected def _root_.OneHom.withBotMap {M N : Type _} [One M] [One N] (f : OneHo
   toFun := WithBot.map f
   map_one' := by rw [WithBot.map_one, map_one, coe_one]
 #align one_hom.with_bot_map OneHom.withBotMap
+#align zero_hom.with_bot_map ZeroHom.withBotMap
 
 /-- A version of `WithBot.map` for `AddHom`s. -/
 @[simps (config := { fullyApplied := false })]

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

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

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

56bf4cd6

Diff

@@ -34,42 +34,42 @@ instance one : One (WithTop α) :=
   ⟨(1 : α)⟩
 #align with_top.has_one WithTop.one
 
-@[simp, norm_cast, to_additive]
+@[to_additive (attr := simp, norm_cast)]
 theorem coe_one : ((1 : α) : WithTop α) = 1 :=
   rfl
 #align with_top.coe_one WithTop.coe_one
 
-@[simp, norm_cast, to_additive]
+@[to_additive (attr := simp, norm_cast)]
 theorem coe_eq_one {a : α} : (a : WithTop α) = 1 ↔ a = 1 :=
   coe_eq_coe
 #align with_top.coe_eq_one WithTop.coe_eq_one
 
-@[simp, norm_cast, to_additive coe_pos]
+@[to_additive (attr := simp, norm_cast) coe_pos]
 theorem one_lt_coe [LT α] {a : α} : 1 < (a : WithTop α) ↔ 1 < a :=
   coe_lt_coe
 #align with_top.one_lt_coe WithTop.one_lt_coe
 
-@[simp, norm_cast, to_additive coe_lt_zero]
+@[to_additive (attr := simp, norm_cast) coe_lt_zero]
 theorem coe_lt_one [LT α] {a : α} : (a : WithTop α) < 1 ↔ a < 1 :=
   coe_lt_coe
 #align with_top.coe_lt_one WithTop.coe_lt_one
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 protected theorem map_one {β} (f : α → β) : (1 : WithTop α).map f = (f 1 : WithTop β) :=
   rfl
 #align with_top.map_one WithTop.map_one
 
-@[simp, norm_cast, to_additive]
+@[to_additive (attr := simp, norm_cast)]
 theorem one_eq_coe {a : α} : 1 = (a : WithTop α) ↔ a = 1 :=
   Trans.trans eq_comm coe_eq_one
 #align with_top.one_eq_coe WithTop.one_eq_coe
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem top_ne_one : ⊤ ≠ (1 : WithTop α) :=
   fun.
 #align with_top.top_ne_one WithTop.top_ne_one
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem one_ne_top : (1 : WithTop α) ≠ ⊤ :=
   fun.
 #align with_top.one_ne_top WithTop.one_ne_top
@@ -483,12 +483,12 @@ theorem coe_eq_one [One α] {a : α} : (a : WithBot α) = 1 ↔ a = 1 :=
   WithTop.coe_eq_one
 #align with_bot.coe_eq_one WithBot.coe_eq_one
 
-@[norm_cast, to_additive coe_pos]
+@[to_additive (attr := norm_cast) coe_pos]
 theorem one_lt_coe [One α] [LT α] {a : α} : 1 < (a : WithBot α) ↔ 1 < a :=
   coe_lt_coe
 #align with_bot.one_lt_coe WithBot.one_lt_coe
 
-@[norm_cast, to_additive coe_lt_zero]
+@[to_additive (attr := norm_cast) coe_lt_zero]
 theorem coe_lt_one [One α] [LT α] {a : α} : (a : WithBot α) < 1 ↔ a < 1 :=
   coe_lt_coe
 #align with_bot.coe_lt_one WithBot.coe_lt_one

feat: port some CanLift instances, restore lift tactic usage (#1425)

93812b0f

Diff

@@ -186,58 +186,42 @@ instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap
 
 protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤)
     (h : a + b ≤ a + c) : b ≤ c := by
-  -- Porting notes : `lift` not implemented yet.
-  -- (This would replace the first two lines)
-  -- -- lift a to α using ha
-  induction a using WithTop.recTopCoe
-  · contradiction
-  · induction c using WithTop.recTopCoe
-    · exact le_top
-    · induction b using WithTop.recTopCoe
-      · exact (not_top_le_coe _ h).elim
-      · simp only [← coe_add, coe_le_coe] at h ⊢
-        exact le_of_add_le_add_left h
+  lift a to α using ha
+  induction c using WithTop.recTopCoe
+  · exact le_top
+  · induction b using WithTop.recTopCoe
+    · exact (not_top_le_coe _ h).elim
+    · simp only [← coe_add, coe_le_coe] at h ⊢
+      exact le_of_add_le_add_left h
 
 #align with_top.le_of_add_le_add_left WithTop.le_of_add_le_add_left
 
 protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
     (ha : a ≠ ⊤) (h : b + a ≤ c + a) : b ≤ c := by
-  -- Porting notes : `lift` not implemented yet.
-  -- First two lines could be replaced with:
-  -- lift a to α using ha
-  induction a using WithTop.recTopCoe
-  · contradiction
-  · cases c
-    · exact le_top
-    · cases b
-      · exact (not_top_le_coe _ h).elim
-      · exact coe_le_coe.2 (le_of_add_le_add_right <| coe_le_coe.1 h)
+  lift a to α using ha
+  cases c
+  · exact le_top
+  · cases b
+    · exact (not_top_le_coe _ h).elim
+    · exact coe_le_coe.2 (le_of_add_le_add_right <| coe_le_coe.1 h)
 #align with_top.le_of_add_le_add_right WithTop.le_of_add_le_add_right
 
 protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : a + b < a + c := by
-  -- Porting notes : `lift` not implemented yet.
-  -- First two lines could be replaced with:
-  -- lift a to α using ha
-  induction a using WithTop.recTopCoe
-  · contradiction
-  · rcases lt_iff_exists_coe.1 h with ⟨b, rfl, h'⟩
-    cases c
-    · exact coe_lt_top _
-    · exact coe_lt_coe.2 (add_lt_add_left (coe_lt_coe.1 h) _)
+  lift a to α using ha
+  rcases lt_iff_exists_coe.1 h with ⟨b, rfl, h'⟩
+  cases c
+  · exact coe_lt_top _
+  · exact coe_lt_coe.2 (add_lt_add_left (coe_lt_coe.1 h) _)
 #align with_top.add_lt_add_left WithTop.add_lt_add_left
 
 protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤)
     (h : b < c) : b + a < c + a := by
-  -- Porting notes : `lift` not implemented yet.
-  -- First two lines could be replaced with:
-  -- lift a to α using ha
-  induction a using WithTop.recTopCoe
-  · contradiction
-  · rcases lt_iff_exists_coe.1 h with ⟨b, rfl, h'⟩
-    cases c
-    · exact coe_lt_top _
-    · exact coe_lt_coe.2 (add_lt_add_right (coe_lt_coe.1 h) _)
+  lift a to α using ha
+  rcases lt_iff_exists_coe.1 h with ⟨b, rfl, h'⟩
+  cases c
+  · exact coe_lt_top _
+  · exact coe_lt_coe.2 (add_lt_add_right (coe_lt_coe.1 h) _)
 #align with_top.add_lt_add_right WithTop.add_lt_add_right
 
 protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (· ≤ ·)]

chore: tidy various files (#1412)

0ee6552e

Diff

@@ -92,24 +92,20 @@ theorem coe_add : ((x + y : α) : WithTop α) = x + y :=
   rfl
 #align with_top.coe_add WithTop.coe_add
 
--- Porting note: Linter says these are syntactic tautologies.
--- Porting note: `bit0` and `bit1` are deprecated. Section can be removed without replacement.
--- section deprecated
--- set_option linter.deprecated false
-
--- --@[norm_cast]
--- @[deprecated]
--- theorem coe_bit0 : ((bit0 x : α) : WithTop α) = bit0 x :=
---   rfl
--- #align with_top.coe_bit0 WithTop.coe_bit0
+section deprecated
+set_option linter.deprecated false
 
--- -- @[norm_cast]
--- @[deprecated]
--- theorem coe_bit1 [One α] {a : α} : ((bit1 a : α) : WithTop α) = bit1 a :=
---   rfl
--- #align with_top.coe_bit1 WithTop.coe_bit1
+@[norm_cast, deprecated]
+theorem coe_bit0 : ((bit0 x : α) : WithTop α) = (bit0 x : WithTop α) :=
+  rfl
+#align with_top.coe_bit0 WithTop.coe_bit0
+
+@[norm_cast, deprecated]
+theorem coe_bit1 [One α] {a : α} : ((bit1 a : α) : WithTop α) = (bit1 a : WithTop α) :=
+  rfl
+#align with_top.coe_bit1 WithTop.coe_bit1
 
--- end deprecated
+end deprecated
 
 @[simp]
 theorem top_add (a : WithTop α) : ⊤ + a = ⊤ :=
@@ -542,22 +538,22 @@ theorem coe_add (a b : α) : ((a + b : α) : WithBot α) = a + b :=
   rfl
 #align with_bot.coe_add WithBot.coe_add
 
--- Porting note: Linter says these are syntactical tautologies now.
--- Porting note: `bit0` and `bit1` are deprecated. Section can be removed without replacement.
--- section deprecated
--- set_option linter.deprecated false
+section deprecated
+set_option linter.deprecated false
 
--- @[deprecated]
--- theorem coe_bit0 : ((bit0 x : α) : WithBot α) = bit0 x :=
---   rfl
--- #align with_bot.coe_bit0 WithBot.coe_bit0
+-- Porting note: added norm_cast
+@[norm_cast, deprecated]
+theorem coe_bit0 : ((bit0 x : α) : WithBot α) = (bit0 x : WithBot α) :=
+  rfl
+#align with_bot.coe_bit0 WithBot.coe_bit0
 
--- @[deprecated]
--- theorem coe_bit1 [One α] {a : α} : ((bit1 a : α) : WithBot α) = bit1 a :=
---   rfl
--- #align with_bot.coe_bit1 WithBot.coe_bit1
+-- Porting note: added norm_cast
+@[norm_cast, deprecated]
+theorem coe_bit1 [One α] {a : α} : ((bit1 a : α) : WithBot α) = (bit1 a : WithBot α) :=
+  rfl
+#align with_bot.coe_bit1 WithBot.coe_bit1
 
--- end deprecated
+end deprecated
 
 @[simp]
 theorem bot_add (a : WithBot α) : ⊥ + a = ⊥ :=

chore: remove iff_self from simp only after lean4#1933 (#1406)

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

72b23bd4

Diff

@@ -138,7 +138,7 @@ theorem add_eq_coe :
   | none, b, c => by simp [none_eq_top]
   | Option.some a, none, c => by simp [none_eq_top]
   | Option.some a, Option.some b, c =>
-  by simp only [some_eq_coe, ← coe_add, coe_eq_coe, exists_and_left, exists_eq_left, iff_self]
+  by simp only [some_eq_coe, ← coe_add, coe_eq_coe, exists_and_left, exists_eq_left]
 #align with_top.add_eq_coe WithTop.add_eq_coe
 
 -- Porting note: simp can already prove this.

chore: update SHA in porting header (#1306)

These files correspond to files flagged "The following files have been modified since the commit at which they were verified." by port_status.py but are in sync with mathlib3, so we can update the hash.

I only updated the easy ones, the others need a closer inspection.

Co-authored-by: Reid Barton <rwbarton@gmail.com>

cac405f4

Diff

@@ -5,7 +5,7 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 Ported by: Jon Eugster
 
 ! This file was ported from Lean 3 source module algebra.order.monoid.with_top
-! leanprover-community/mathlib commit 655994e298904d7e5bbd1e18c95defd7b543eb94
+! leanprover-community/mathlib commit 2258b40dacd2942571c8ce136215350c702dc78f
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

chore: fix casing per naming scheme (#1183)

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

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

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

71723d8b

Diff

@@ -537,7 +537,7 @@ section Add
 
 variable [Add α] {a b c d : WithBot α} {x y : α}
 
--- `norm_cast` proves those lemmas, because `with_top`/`with_bot` are reducible
+-- `norm_cast` proves those lemmas, because `WithTop`/`WithBot` are reducible
 theorem coe_add (a b : α) : ((a + b : α) : WithBot α) = a + b :=
   rfl
 #align with_bot.coe_add WithBot.coe_add
@@ -613,7 +613,7 @@ protected def _root_.OneHom.withBotMap {M N : Type _} [One M] [One N] (f : OneHo
   map_one' := by rw [WithBot.map_one, map_one, coe_one]
 #align one_hom.with_bot_map OneHom.withBotMap
 
-/-- A version of `with_bot.map` for `add_hom`s. -/
+/-- A version of `WithBot.map` for `AddHom`s. -/
 @[simps (config := { fullyApplied := false })]
 protected def _root_.AddHom.withBotMap {M N : Type _} [Add M] [Add N] (f : AddHom M N) :
     AddHom (WithBot M) (WithBot N) where
@@ -621,7 +621,7 @@ protected def _root_.AddHom.withBotMap {M N : Type _} [Add M] [Add N] (f : AddHo
   map_add' := WithBot.map_add f
 #align add_hom.with_bot_map AddHom.withBotMap
 
-/-- A version of `with_bot.map` for `add_monoid_hom`s. -/
+/-- A version of `WithBot.map` for `AddMonoidHom`s. -/
 @[simps (config := { fullyApplied := false })]
 protected def _root_.AddMonoidHom.withBotMap {M N : Type _} [AddZeroClass M] [AddZeroClass N]
     (f : M →+ N) : WithBot M →+ WithBot N :=
@@ -630,15 +630,15 @@ protected def _root_.AddMonoidHom.withBotMap {M N : Type _} [AddZeroClass M] [Ad
 
 variable [Preorder α]
 
-instance covariant_class_add_le [CovariantClass α α (· + ·) (· ≤ ·)] :
+instance covariantClass_add_le [CovariantClass α α (· + ·) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (· + ·) (· ≤ ·) :=
   @OrderDual.covariantClass_add_le (WithTop αᵒᵈ) _ _ _
-#align with_bot.covariant_class_add_le WithBot.covariant_class_add_le
+#align with_bot.covariant_class_add_le WithBot.covariantClass_add_le
 
-instance covariant_class_swap_add_le [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
+instance covariantClass_swap_add_le [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
     CovariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· ≤ ·) :=
   @OrderDual.covariantClass_swap_add_le (WithTop αᵒᵈ) _ _ _
-#align with_bot.covariant_class_swap_add_le WithBot.covariant_class_swap_add_le
+#align with_bot.covariant_class_swap_add_le WithBot.covariantClass_swap_add_le
 
 instance contravariantClass_add_lt [ContravariantClass α α (· + ·) (· < ·)] :
     ContravariantClass (WithBot α) (WithBot α) (· + ·) (· < ·) :=

chore: update lean4/std4 (#1096)

a9a1f7d7

Diff

@@ -131,7 +131,6 @@ theorem add_ne_top : a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ :=
 
 theorem add_lt_top [PartialOrder α] {a b : WithTop α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ := by
   simp_rw [lt_top_iff_ne_top, add_ne_top]
-  rfl
 #align with_top.add_lt_top WithTop.add_lt_top
 
 theorem add_eq_coe :