order.with_bot | Mathlib porting status

(last sync)

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

Diff

@@ -48,6 +48,8 @@ meta instance {α : Type} [reflected _ α] [has_reflect α] : has_reflect (with_
 
 instance : inhabited (with_bot α) := ⟨⊥⟩
 
+instance [nonempty α] : nontrivial (with_bot α) := option.nontrivial
+
 open function
 
 lemma coe_injective : injective (coe : α → with_bot α) := option.some_injective _
@@ -420,6 +422,8 @@ meta instance {α : Type} [reflected _ α] [has_reflect α] : has_reflect (with_
 
 instance : inhabited (with_top α) := ⟨⊤⟩
 
+instance [nonempty α] : nontrivial (with_top α) := option.nontrivial
+
 protected lemma «forall» {p : with_top α → Prop} : (∀ x, p x) ↔ p ⊤ ∧ ∀ x : α, p x := option.forall
 protected lemma «exists» {p : with_top α → Prop} : (∃ x, p x) ↔ p ⊤ ∨ ∃ x : α, p x := option.exists

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

Backport leanprover-community/mathlib4#2406

Diff

@@ -82,6 +82,17 @@ def unbot' (d : α) (x : with_bot α) : α := rec_bot_coe d id x
 
 @[norm_cast] lemma coe_eq_coe : (a : with_bot α) = b ↔ a = b := option.some_inj
 
+lemma unbot'_eq_iff {d y : α} {x : with_bot α} : unbot' d x = y ↔ x = y ∨ x = ⊥ ∧ y = d :=
+by induction x using with_bot.rec_bot_coe; simp [@eq_comm _ d, coe_eq_coe]
+
+@[simp]
+theorem unbot'_eq_self_iff {d : α} {x : with_bot α} : unbot' d x = d ↔ x = d ∨ x = ⊥ :=
+by simp [unbot'_eq_iff]
+
+theorem unbot'_eq_unbot'_iff {d : α} {x y : with_bot α} :
+  unbot' d x = unbot' d y ↔ x = y ∨ x = d ∧ y = ⊥ ∨ x = ⊥ ∧ y = d :=
+by induction y using with_bot.rec_bot_coe; simp [unbot'_eq_iff, or_comm, coe_eq_coe]
+
 /-- Lift a map `f : α → β` to `with_bot α → with_bot β`. Implemented using `option.map`. -/
 def map (f : α → β) : with_bot α → with_bot β := option.map f
 
@@ -172,6 +183,12 @@ lemma lt_coe_iff : ∀ {x : with_bot α}, x < b ↔ ∀ a, x = ↑a → a < b
 | (some b) := by simp [some_eq_coe, coe_eq_coe, coe_lt_coe]
 | none     := by simp [none_eq_bot, bot_lt_coe]
 
+/-- A version of `bot_lt_iff_ne_bot` for `with_bot` that only requires `has_lt α`, not
+`partial_order α`. -/
+protected theorem bot_lt_iff_ne_bot : ∀ {x : with_bot α}, ⊥ < x ↔ x ≠ ⊥
+| ⊥ := iff_of_false (with_bot.not_lt_none _) (λ h, h rfl)
+| (x : α) := by simp [bot_lt_coe]
+
 end has_lt
 
 instance [preorder α] : preorder (with_bot α) :=
@@ -462,6 +479,16 @@ def untop' (d : α) (x : with_top α) : α := rec_top_coe d id x
 
 @[norm_cast] lemma coe_eq_coe : (a : with_top α) = b ↔ a = b := option.some_inj
 
+lemma untop'_eq_iff {d y : α} {x : with_top α} : untop' d x = y ↔ x = y ∨ x = ⊤ ∧ y = d :=
+with_bot.unbot'_eq_iff
+
+@[simp] theorem untop'_eq_self_iff {d : α} {x : with_top α} : untop' d x = d ↔ x = d ∨ x = ⊤ :=
+with_bot.unbot'_eq_self_iff
+
+theorem untop'_eq_untop'_iff {d : α} {x y : with_top α} :
+  untop' d x = untop' d y ↔ x = y ∨ x = d ∧ y = ⊤ ∨ x = ⊤ ∧ y = d :=
+with_bot.unbot'_eq_unbot'_iff
+
 /-- Lift a map `f : α → β` to `with_top α → with_top β`. Implemented using `option.map`. -/
 def map (f : α → β) : with_top α → with_top β := option.map f
 
@@ -679,6 +706,11 @@ begin
   exact forall₂_congr (λ _ _, iff.rfl)
 end
 
+/-- A version of `lt_top_iff_ne_top` for `with_top` that only requires `has_lt α`, not
+`partial_order α`. -/
+protected theorem lt_top_iff_ne_top {x : with_top α} : x < ⊤ ↔ x ≠ ⊤ :=
+@with_bot.bot_lt_iff_ne_bot αᵒᵈ _ x
+
 end has_lt
 
 instance [preorder α] : preorder (with_top α) :=

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

@@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
 -/
 import order.bounded_order
+import data.option.n_ary
 
 /-!
 # `with_bot`, `with_top`
@@ -261,13 +262,13 @@ instance [semilattice_sup α] : semilattice_sup (with_bot α) :=
 lemma coe_sup [semilattice_sup α] (a b : α) : ((a ⊔ b : α) : with_bot α) = a ⊔ b := rfl
 
 instance [semilattice_inf α] : semilattice_inf (with_bot α) :=
-{ inf          := λ o₁ o₂, o₁.bind (λ a, o₂.map (λ b, a ⊓ b)),
+{ inf          := option.map₂ (⊓),
   inf_le_left  := λ o₁ o₂ a ha, begin
-    simp [map] at ha, rcases ha with ⟨b, rfl, c, rfl, rfl⟩,
+    rcases option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩,
     exact ⟨_, rfl, inf_le_left⟩
   end,
   inf_le_right := λ o₁ o₂ a ha, begin
-    simp [map] at ha, rcases ha with ⟨b, rfl, c, rfl, rfl⟩,
+    rcases option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩,
     exact ⟨_, rfl, inf_le_right⟩
   end,
   le_inf       := λ o₁ o₂ o₃ h₁ h₂ a ha, begin
@@ -746,13 +747,13 @@ instance [semilattice_inf α] : semilattice_inf (with_top α) :=
 lemma coe_inf [semilattice_inf α] (a b : α) : ((a ⊓ b : α) : with_top α) = a ⊓ b := rfl
 
 instance [semilattice_sup α] : semilattice_sup (with_top α) :=
-{ sup          := λ o₁ o₂, o₁.bind (λ a, o₂.map (λ b, a ⊔ b)),
+{ sup          := option.map₂ (⊔),
   le_sup_left  := λ o₁ o₂ a ha, begin
-    simp [map] at ha, rcases ha with ⟨b, rfl, c, rfl, rfl⟩,
+    rcases option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩,
     exact ⟨_, rfl, le_sup_left⟩
   end,
   le_sup_right := λ o₁ o₂ a ha, begin
-    simp [map] at ha, rcases ha with ⟨b, rfl, c, rfl, rfl⟩,
+    rcases option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩,
     exact ⟨_, rfl, le_sup_right⟩
   end,
   sup_le       := λ o₁ o₂ o₃ h₁ h₂ a ha, begin

(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

@@ -186,7 +186,7 @@ theorem unbot'_eq_self_iff {d : α} {x : WithBot α} : unbot' d x = d ↔ x = d
 #print WithBot.unbot'_eq_unbot'_iff /-
 theorem unbot'_eq_unbot'_iff {d : α} {x y : WithBot α} :
     unbot' d x = unbot' d y ↔ x = y ∨ x = d ∧ y = ⊥ ∨ x = ⊥ ∧ y = d := by
-  induction y using WithBot.recBotCoe <;> simp [unbot'_eq_iff, or_comm', coe_eq_coe]
+  induction y using WithBot.recBotCoe <;> simp [unbot'_eq_iff, or_comm, coe_eq_coe]
 #align with_bot.unbot'_eq_unbot'_iff WithBot.unbot'_eq_unbot'_iff
 -/

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -506,7 +506,7 @@ instance [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
       · exact h₂ a rfl
       · exact h₁ a rfl
       · rcases h₁ b rfl with ⟨d, ⟨⟩, h₁'⟩
-        simp at h₂ 
+        simp at h₂
         exact ⟨d, rfl, sup_le h₁' h₂⟩ }
 
 #print WithBot.coe_sup /-
@@ -1095,7 +1095,7 @@ protected theorem IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) :=
   by
   -- defeq to is_max_to_dual_iff.mp (is_max.with_bot _), but that breaks API boundary
   intro _ hb
-  rw [← to_dual_le_to_dual_iff] at hb 
+  rw [← to_dual_le_to_dual_iff] at hb
   simpa [to_dual_le_iff] using (IsMax.withBot h : IsMax (to_dual a : WithBot αᵒᵈ)) hb
 #align is_min.with_top IsMin.withTop
 -/
@@ -1484,7 +1484,7 @@ instance [SemilatticeInf α] : SemilatticeInf (WithTop α) :=
       · exact h₂ a rfl
       · exact h₁ a rfl
       · rcases h₁ b rfl with ⟨d, ⟨⟩, h₁'⟩
-        simp at h₂ 
+        simp at h₂
         exact ⟨d, rfl, le_inf h₁' h₂⟩ }
 
 #print WithTop.coe_inf /-

bump to nightly-2023-11-05-06

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

acc3325f

Diff

@@ -600,8 +600,8 @@ theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = ma
 #align with_bot.coe_max WithBot.coe_max
 -/
 
-#print WithBot.wellFounded_lt /-
-theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
+#print WithBot.instWellFoundedLT /-
+theorem instWellFoundedLT [Preorder α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithBot α) (· < ·) :=
   have acc_bot : Acc ((· < ·) : WithBot α → WithBot α → Prop) ⊥ :=
     Acc.intro _ fun a ha => (not_le_of_gt ha bot_le).elim
@@ -619,7 +619,7 @@ theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
               Acc.intro _ fun c =>
                 Option.recOn c (fun _ => acc_bot) fun c hc =>
                   ih _ (some_lt_some.1 hc) (lt_trans hc hba))⟩
-#align with_bot.well_founded_lt WithBot.wellFounded_lt
+#align with_bot.well_founded_lt WithBot.instWellFoundedLT
 -/
 
 instance [LT α] [DenselyOrdered α] [NoMinOrder α] : DenselyOrdered (WithBot α) :=
@@ -1564,8 +1564,8 @@ theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max
 #align with_top.coe_max WithTop.coe_max
 -/
 
-#print WithTop.wellFounded_lt /-
-theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
+#print WithTop.instWellFoundedLT /-
+theorem instWellFoundedLT [Preorder α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithTop α) (· < ·) :=
   have acc_some : ∀ a : α, Acc ((· < ·) : WithTop α → WithTop α → Prop) (some a) := fun a =>
     Acc.intro _
@@ -1581,37 +1581,37 @@ theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
     Option.recOn a
       (Acc.intro _ fun y => Option.recOn y (fun h => (lt_irrefl _ h).elim) fun _ _ => acc_some _)
       acc_some⟩
-#align with_top.well_founded_lt WithTop.wellFounded_lt
+#align with_top.well_founded_lt WithTop.instWellFoundedLT
 -/
 
 open OrderDual
 
-#print WithTop.wellFounded_gt /-
-theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
+#print WithTop.instWellFoundedGT /-
+theorem instWellFoundedGT [Preorder α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithTop α) (· > ·) :=
   ⟨fun a =>
     by
     -- ideally, use rel_hom_class.acc, but that is defined later
-    have : Acc (· < ·) a.to_dual := WellFounded.apply (WithBot.wellFounded_lt h) _
+    have : Acc (· < ·) a.to_dual := WellFounded.apply (WithBot.instWellFoundedLT h) _
     revert this
     generalize ha : a.to_dual = b; intro ac
     induction' ac with _ H IH generalizing a; subst ha
     exact ⟨_, fun a' h => IH a'.toDual (to_dual_lt_to_dual.mpr h) _ rfl⟩⟩
-#align with_top.well_founded_gt WithTop.wellFounded_gt
+#align with_top.well_founded_gt WithTop.instWellFoundedGT
 -/
 
-#print WithBot.wellFounded_gt /-
-theorem WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
+#print WithBot.instWellFoundedGT /-
+theorem WithBot.instWellFoundedGT [Preorder α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithBot α) (· > ·) :=
   ⟨fun a =>
     by
     -- ideally, use rel_hom_class.acc, but that is defined later
-    have : Acc (· < ·) a.to_dual := WellFounded.apply (WithTop.wellFounded_lt h) _
+    have : Acc (· < ·) a.to_dual := WellFounded.apply (WithTop.instWellFoundedLT h) _
     revert this
     generalize ha : a.to_dual = b; intro ac
     induction' ac with _ H IH generalizing a; subst ha
     exact ⟨_, fun a' h => IH a'.toDual (to_dual_lt_to_dual.mpr h) _ rfl⟩⟩
-#align with_bot.well_founded_gt WithBot.wellFounded_gt
+#align with_bot.well_founded_gt WithBot.instWellFoundedGT
 -/
 
 #print WithTop.trichotomous.lt /-
@@ -1626,7 +1626,7 @@ instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
 
 #print WithTop.IsWellOrder.lt /-
 instance IsWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] : IsWellOrder (WithTop α) (· < ·)
-    where wf := wellFounded_lt h.wf
+    where wf := instWellFoundedLT h.wf
 #align with_top.is_well_order.lt WithTop.IsWellOrder.lt
 -/
 
@@ -1642,7 +1642,7 @@ instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
 
 #print WithTop.IsWellOrder.gt /-
 instance IsWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] : IsWellOrder (WithTop α) (· > ·)
-    where wf := wellFounded_gt h.wf
+    where wf := instWellFoundedGT h.wf
 #align with_top.is_well_order.gt WithTop.IsWellOrder.gt
 -/

bump to nightly-2023-09-27-06

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

b3e015b8

Diff

@@ -480,10 +480,10 @@ theorem le_coe_unbot' [Preorder α] : ∀ (a : WithBot α) (b : α), a ≤ a.unb
 #align with_bot.le_coe_unbot' WithBot.le_coe_unbot'
 -/
 
-#print WithBot.unbot'_bot_le_iff /-
-theorem unbot'_bot_le_iff [LE α] [OrderBot α] {a : WithBot α} {b : α} : a.unbot' ⊥ ≤ b ↔ a ≤ b := by
+#print WithBot.unbot'_le_iff /-
+theorem unbot'_le_iff [LE α] [OrderBot α] {a : WithBot α} {b : α} : a.unbot' ⊥ ≤ b ↔ a ≤ b := by
   cases a <;> simp [none_eq_bot, some_eq_coe]
-#align with_bot.unbot'_bot_le_iff WithBot.unbot'_bot_le_iff
+#align with_bot.unbot'_bot_le_iff WithBot.unbot'_le_iff
 -/
 
 #print WithBot.unbot'_lt_iff /-

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
 -/
-import Mathbin.Order.BoundedOrder
-import Mathbin.Data.Option.NAry
+import Order.BoundedOrder
+import Data.Option.NAry
 
 #align_import order.with_bot from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"

bump to nightly-2023-08-23-23

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

f612b9e0

Diff

@@ -440,7 +440,7 @@ theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
 #align with_bot.monotone_map_iff WithBot.monotone_map_iff
 -/
 
-alias monotone_map_iff ↔ _ _root_.monotone.with_bot_map
+alias ⟨_, _root_.monotone.with_bot_map⟩ := monotone_map_iff
 #align monotone.with_bot_map Monotone.withBot_map
 
 #print WithBot.strictMono_iff /-
@@ -461,7 +461,7 @@ theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
 #align with_bot.strict_mono_map_iff WithBot.strictMono_map_iff
 -/
 
-alias strict_mono_map_iff ↔ _ _root_.strict_mono.with_bot_map
+alias ⟨_, _root_.strict_mono.with_bot_map⟩ := strict_mono_map_iff
 #align strict_mono.with_bot_map StrictMono.withBot_map
 
 #print WithBot.map_le_iff /-
@@ -1439,7 +1439,7 @@ theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
 #align with_top.monotone_map_iff WithTop.monotone_map_iff
 -/
 
-alias monotone_map_iff ↔ _ _root_.monotone.with_top_map
+alias ⟨_, _root_.monotone.with_top_map⟩ := monotone_map_iff
 #align monotone.with_top_map Monotone.withTop_map
 
 #print WithTop.strictMono_iff /-
@@ -1460,7 +1460,7 @@ theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
 #align with_top.strict_mono_map_iff WithTop.strictMono_map_iff
 -/
 
-alias strict_mono_map_iff ↔ _ _root_.strict_mono.with_top_map
+alias ⟨_, _root_.strict_mono.with_top_map⟩ := strict_mono_map_iff
 #align strict_mono.with_top_map StrictMono.withTop_map
 
 #print WithTop.map_le_iff /-

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
-
-! This file was ported from Lean 3 source module order.with_bot
-! 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.Order.BoundedOrder
 import Mathbin.Data.Option.NAry
 
+#align_import order.with_bot from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
+
 /-!
 # `with_bot`, `with_top`

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -128,17 +128,21 @@ def recBotCoe {C : WithBot α → Sort _} (h₁ : C ⊥) (h₂ : ∀ a : α, C a
 #align with_bot.rec_bot_coe WithBot.recBotCoe
 -/
 
+#print WithBot.recBotCoe_bot /-
 @[simp]
 theorem recBotCoe_bot {C : WithBot α → Sort _} (d : C ⊥) (f : ∀ a : α, C a) :
     @recBotCoe _ C d f ⊥ = d :=
   rfl
 #align with_bot.rec_bot_coe_bot WithBot.recBotCoe_bot
+-/
 
+#print WithBot.recBotCoe_coe /-
 @[simp]
 theorem recBotCoe_coe {C : WithBot α → Sort _} (d : C ⊥) (f : ∀ a : α, C a) (x : α) :
     @recBotCoe _ C d f ↑x = f x :=
   rfl
 #align with_bot.rec_bot_coe_coe WithBot.recBotCoe_coe
+-/
 
 #print WithBot.unbot' /-
 /-- Specialization of `option.get_or_else` to values in `with_bot α` that respects API boundaries.
@@ -210,10 +214,12 @@ theorem map_coe (f : α → β) (a : α) : map f a = f a :=
 #align with_bot.map_coe WithBot.map_coe
 -/
 
+#print WithBot.map_comm /-
 theorem map_comm {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂ : γ → δ} (h : g₁ ∘ f₁ = g₂ ∘ f₂)
     (a : α) : map g₁ (map f₁ a) = map g₂ (map f₂ a) :=
   Option.map_comm h _
 #align with_bot.map_comm WithBot.map_comm
+-/
 
 #print WithBot.ne_bot_iff_exists /-
 theorem ne_bot_iff_exists {x : WithBot α} : x ≠ ⊥ ↔ ∃ a : α, ↑a = x :=
@@ -256,18 +262,24 @@ variable [LE α]
 instance (priority := 10) : LE (WithBot α) :=
   ⟨fun o₁ o₂ : Option α => ∀ a ∈ o₁, ∃ b ∈ o₂, a ≤ b⟩
 
+#print WithBot.some_le_some /-
 @[simp]
 theorem some_le_some : @LE.le (WithBot α) _ (some a) (some b) ↔ a ≤ b := by simp [(· ≤ ·)]
 #align with_bot.some_le_some WithBot.some_le_some
+-/
 
+#print WithBot.coe_le_coe /-
 @[simp, norm_cast]
 theorem coe_le_coe : (a : WithBot α) ≤ b ↔ a ≤ b :=
   some_le_some
 #align with_bot.coe_le_coe WithBot.coe_le_coe
+-/
 
+#print WithBot.none_le /-
 @[simp]
 theorem none_le {a : WithBot α} : @LE.le (WithBot α) _ none a := fun b h => Option.noConfusion h
 #align with_bot.none_le WithBot.none_le
+-/
 
 instance : OrderBot (WithBot α) :=
   { WithBot.hasBot with bot_le := fun a => none_le }
@@ -280,29 +292,39 @@ instance [OrderTop α] : OrderTop (WithBot α)
 instance [OrderTop α] : BoundedOrder (WithBot α) :=
   { WithBot.orderTop, WithBot.orderBot with }
 
+#print WithBot.not_coe_le_bot /-
 theorem not_coe_le_bot (a : α) : ¬(a : WithBot α) ≤ ⊥ := fun h =>
   let ⟨b, hb, _⟩ := h _ rfl
   Option.not_mem_none _ hb
 #align with_bot.not_coe_le_bot WithBot.not_coe_le_bot
+-/
 
+#print WithBot.coe_le /-
 theorem coe_le : ∀ {o : Option α}, b ∈ o → ((a : WithBot α) ≤ o ↔ a ≤ b)
   | _, rfl => coe_le_coe
 #align with_bot.coe_le WithBot.coe_le
+-/
 
+#print WithBot.coe_le_iff /-
 theorem coe_le_iff : ∀ {x : WithBot α}, ↑a ≤ x ↔ ∃ b : α, x = b ∧ a ≤ b
   | some a => by simp [some_eq_coe, coe_eq_coe]
   | none => iff_of_false (not_coe_le_bot _) <| by simp [none_eq_bot]
 #align with_bot.coe_le_iff WithBot.coe_le_iff
+-/
 
+#print WithBot.le_coe_iff /-
 theorem le_coe_iff : ∀ {x : WithBot α}, x ≤ b ↔ ∀ a, x = ↑a → a ≤ b
   | some b => by simp [some_eq_coe, coe_eq_coe]
   | none => by simp [none_eq_bot]
 #align with_bot.le_coe_iff WithBot.le_coe_iff
+-/
 
+#print IsMax.withBot /-
 protected theorem IsMax.withBot (h : IsMax a) : IsMax (a : WithBot α)
   | none, _ => bot_le
   | some b, hb => some_le_some.2 <| h <| some_le_some.1 hb
 #align is_max.with_bot IsMax.withBot
+-/
 
 end LE
 
@@ -313,45 +335,61 @@ variable [LT α]
 instance (priority := 10) : LT (WithBot α) :=
   ⟨fun o₁ o₂ : Option α => ∃ b ∈ o₂, ∀ a ∈ o₁, a < b⟩
 
+#print WithBot.some_lt_some /-
 @[simp]
 theorem some_lt_some : @LT.lt (WithBot α) _ (some a) (some b) ↔ a < b := by simp [(· < ·)]
 #align with_bot.some_lt_some WithBot.some_lt_some
+-/
 
+#print WithBot.coe_lt_coe /-
 @[simp, norm_cast]
 theorem coe_lt_coe : (a : WithBot α) < b ↔ a < b :=
   some_lt_some
 #align with_bot.coe_lt_coe WithBot.coe_lt_coe
+-/
 
+#print WithBot.none_lt_some /-
 @[simp]
 theorem none_lt_some (a : α) : @LT.lt (WithBot α) _ none (some a) :=
   ⟨a, rfl, fun b hb => (Option.not_mem_none _ hb).elim⟩
 #align with_bot.none_lt_some WithBot.none_lt_some
+-/
 
+#print WithBot.bot_lt_coe /-
 theorem bot_lt_coe (a : α) : (⊥ : WithBot α) < a :=
   none_lt_some a
 #align with_bot.bot_lt_coe WithBot.bot_lt_coe
+-/
 
+#print WithBot.not_lt_none /-
 @[simp]
 theorem not_lt_none (a : WithBot α) : ¬@LT.lt (WithBot α) _ a none := fun ⟨_, h, _⟩ =>
   Option.not_mem_none _ h
 #align with_bot.not_lt_none WithBot.not_lt_none
+-/
 
+#print WithBot.lt_iff_exists_coe /-
 theorem lt_iff_exists_coe : ∀ {a b : WithBot α}, a < b ↔ ∃ p : α, b = p ∧ a < p
   | a, some b => by simp [some_eq_coe, coe_eq_coe]
   | a, none => iff_of_false (not_lt_none _) <| by simp [none_eq_bot]
 #align with_bot.lt_iff_exists_coe WithBot.lt_iff_exists_coe
+-/
 
+#print WithBot.lt_coe_iff /-
 theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a, x = ↑a → a < b
   | some b => by simp [some_eq_coe, coe_eq_coe, coe_lt_coe]
   | none => by simp [none_eq_bot, bot_lt_coe]
 #align with_bot.lt_coe_iff WithBot.lt_coe_iff
+-/
 
+#print WithBot.bot_lt_iff_ne_bot /-
 /-- A version of `bot_lt_iff_ne_bot` for `with_bot` that only requires `has_lt α`, not
 `partial_order α`. -/
 protected theorem bot_lt_iff_ne_bot : ∀ {x : WithBot α}, ⊥ < x ↔ x ≠ ⊥
   | ⊥ => iff_of_false (WithBot.not_lt_none _) fun h => h rfl
   | (x : α) => by simp [bot_lt_coe]
 #align with_bot.bot_lt_iff_ne_bot WithBot.bot_lt_iff_ne_bot
+-/
 
 end LT
 
@@ -387,6 +425,7 @@ theorem coe_mono [Preorder α] : Monotone (coe : α → WithBot α) := fun a b =
 #align with_bot.coe_mono WithBot.coe_mono
 -/
 
+#print WithBot.monotone_iff /-
 theorem monotone_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
     Monotone f ↔ Monotone (f ∘ coe : α → β) ∧ ∀ x : α, f ⊥ ≤ f x :=
   ⟨fun h => ⟨h.comp WithBot.coe_mono, fun x => h bot_le⟩, fun h =>
@@ -394,16 +433,20 @@ theorem monotone_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
       ⟨WithBot.forall.2 ⟨fun _ => le_rfl, fun x _ => h.2 x⟩, fun x =>
         WithBot.forall.2 ⟨fun h => (not_coe_le_bot _ h).elim, fun y hle => h.1 (coe_le_coe.1 hle)⟩⟩⟩
 #align with_bot.monotone_iff WithBot.monotone_iff
+-/
 
+#print WithBot.monotone_map_iff /-
 @[simp]
 theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
     Monotone (WithBot.map f) ↔ Monotone f :=
   monotone_iff.trans <| by simp [Monotone]
 #align with_bot.monotone_map_iff WithBot.monotone_map_iff
+-/
 
 alias monotone_map_iff ↔ _ _root_.monotone.with_bot_map
 #align monotone.with_bot_map Monotone.withBot_map
 
+#print WithBot.strictMono_iff /-
 theorem strictMono_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
     StrictMono f ↔ StrictMono (f ∘ coe : α → β) ∧ ∀ x : α, f ⊥ < f x :=
   ⟨fun h => ⟨h.comp WithBot.coe_strictMono, fun x => h (bot_lt_coe _)⟩, fun h =>
@@ -411,22 +454,27 @@ theorem strictMono_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
       ⟨WithBot.forall.2 ⟨flip absurd (lt_irrefl _), fun x _ => h.2 x⟩, fun x =>
         WithBot.forall.2 ⟨fun h => (not_lt_bot h).elim, fun y hle => h.1 (coe_lt_coe.1 hle)⟩⟩⟩
 #align with_bot.strict_mono_iff WithBot.strictMono_iff
+-/
 
+#print WithBot.strictMono_map_iff /-
 @[simp]
 theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
     StrictMono (WithBot.map f) ↔ StrictMono f :=
   strictMono_iff.trans <| by simp [StrictMono, bot_lt_coe]
 #align with_bot.strict_mono_map_iff WithBot.strictMono_map_iff
+-/
 
 alias strict_mono_map_iff ↔ _ _root_.strict_mono.with_bot_map
 #align strict_mono.with_bot_map StrictMono.withBot_map
 
+#print WithBot.map_le_iff /-
 theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
     ∀ a b : WithBot α, a.map f ≤ b.map f ↔ a ≤ b
   | ⊥, _ => by simp only [map_bot, bot_le]
   | (a : α), ⊥ => by simp only [map_coe, map_bot, coe_ne_bot, not_coe_le_bot _]
   | (a : α), (b : α) => by simpa only [map_coe, coe_le_coe] using mono_iff
 #align with_bot.map_le_iff WithBot.map_le_iff
+-/
 
 #print WithBot.le_coe_unbot' /-
 theorem le_coe_unbot' [Preorder α] : ∀ (a : WithBot α) (b : α), a ≤ a.unbot' b
@@ -435,15 +483,19 @@ theorem le_coe_unbot' [Preorder α] : ∀ (a : WithBot α) (b : α), a ≤ a.unb
 #align with_bot.le_coe_unbot' WithBot.le_coe_unbot'
 -/
 
+#print WithBot.unbot'_bot_le_iff /-
 theorem unbot'_bot_le_iff [LE α] [OrderBot α] {a : WithBot α} {b : α} : a.unbot' ⊥ ≤ b ↔ a ≤ b := by
   cases a <;> simp [none_eq_bot, some_eq_coe]
 #align with_bot.unbot'_bot_le_iff WithBot.unbot'_bot_le_iff
+-/
 
+#print WithBot.unbot'_lt_iff /-
 theorem unbot'_lt_iff [LT α] {a : WithBot α} {b c : α} (ha : a ≠ ⊥) : a.unbot' b < c ↔ a < c :=
   by
   lift a to α using ha
   rw [unbot'_coe, coe_lt_coe]
 #align with_bot.unbot'_lt_iff WithBot.unbot'_lt_iff
+-/
 
 instance [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
   { WithBot.orderBot,
@@ -460,9 +512,11 @@ instance [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
         simp at h₂ 
         exact ⟨d, rfl, sup_le h₁' h₂⟩ }
 
+#print WithBot.coe_sup /-
 theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithBot α) = a ⊔ b :=
   rfl
 #align with_bot.coe_sup WithBot.coe_sup
+-/
 
 instance [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
   { WithBot.orderBot,
@@ -482,9 +536,11 @@ instance [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
       rcases h₂ a rfl with ⟨c, ⟨⟩, ac⟩
       exact ⟨_, rfl, le_inf ab ac⟩ }
 
+#print WithBot.coe_inf /-
 theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithBot α) = a ⊓ b :=
   rfl
 #align with_bot.coe_inf WithBot.coe_inf
+-/
 
 instance [Lattice α] : Lattice (WithBot α) :=
   { WithBot.semilatticeSup, WithBot.semilatticeInf with }
@@ -502,18 +558,23 @@ instance [DistribLattice α] : DistribLattice (WithBot α) :=
       | (a₁ : α), (a₂ : α), ⊥ => inf_le_right
       | (a₁ : α), (a₂ : α), (a₃ : α) => coe_le_coe.mpr le_sup_inf }
 
+#print WithBot.decidableLE /-
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
   | none, x => isTrue fun a h => Option.noConfusion h
   | some x, some y => if h : x ≤ y then isTrue (some_le_some.2 h) else isFalse <| by simp [*]
   | some x, none => isFalse fun h => by rcases h x rfl with ⟨y, ⟨_⟩, _⟩
 #align with_bot.decidable_le WithBot.decidableLE
+-/
 
+#print WithBot.decidableLT /-
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
   | none, some x => isTrue <| by exists x, rfl <;> rintro _ ⟨⟩
   | some x, some y => if h : x < y then isTrue <| by simp [*] else isFalse <| by simp [*]
   | x, none => isFalse <| by rintro ⟨a, ⟨⟨⟩⟩⟩
 #align with_bot.decidable_lt WithBot.decidableLT
+-/
 
+#print WithBot.isTotal_le /-
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithBot α) (· ≤ ·) :=
   ⟨fun a b =>
     match a, b with
@@ -521,21 +582,26 @@ instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithBot α) (·
     | _, none => Or.inr bot_le
     | some x, some y => (total_of (· ≤ ·) x y).imp some_le_some.2 some_le_some.2⟩
 #align with_bot.is_total_le WithBot.isTotal_le
+-/
 
 instance [LinearOrder α] : LinearOrder (WithBot α) :=
   Lattice.toLinearOrder _
 
+#print WithBot.coe_min /-
 -- this is not marked simp because the corresponding with_top lemmas are used
 @[norm_cast]
 theorem coe_min [LinearOrder α] (x y : α) : ((min x y : α) : WithBot α) = min x y :=
   rfl
 #align with_bot.coe_min WithBot.coe_min
+-/
 
+#print WithBot.coe_max /-
 -- this is not marked simp because the corresponding with_top lemmas are used
 @[norm_cast]
 theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = max x y :=
   rfl
 #align with_bot.coe_max WithBot.coe_max
+-/
 
 #print WithBot.wellFounded_lt /-
 theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
@@ -686,17 +752,21 @@ def recTopCoe {C : WithTop α → Sort _} (h₁ : C ⊤) (h₂ : ∀ a : α, C a
 #align with_top.rec_top_coe WithTop.recTopCoe
 -/
 
+#print WithTop.recTopCoe_top /-
 @[simp]
 theorem recTopCoe_top {C : WithTop α → Sort _} (d : C ⊤) (f : ∀ a : α, C a) :
     @recTopCoe _ C d f ⊤ = d :=
   rfl
 #align with_top.rec_top_coe_top WithTop.recTopCoe_top
+-/
 
+#print WithTop.recTopCoe_coe /-
 @[simp]
 theorem recTopCoe_coe {C : WithTop α → Sort _} (d : C ⊤) (f : ∀ a : α, C a) (x : α) :
     @recTopCoe _ C d f ↑x = f x :=
   rfl
 #align with_top.rec_top_coe_coe WithTop.recTopCoe_coe
+-/
 
 #print WithTop.toDual /-
 /-- `with_top.to_dual` is the equivalence sending `⊤` to `⊥` and any `a : α` to `to_dual a : αᵒᵈ`.
@@ -848,29 +918,39 @@ theorem map_coe (f : α → β) (a : α) : map f a = f a :=
 #align with_top.map_coe WithTop.map_coe
 -/
 
+#print WithTop.map_comm /-
 theorem map_comm {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂ : γ → δ} (h : g₁ ∘ f₁ = g₂ ∘ f₂)
     (a : α) : map g₁ (map f₁ a) = map g₂ (map f₂ a) :=
   Option.map_comm h _
 #align with_top.map_comm WithTop.map_comm
+-/
 
+#print WithTop.map_toDual /-
 theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithBot α) :
     map f (WithBot.toDual a) = a.map (toDual ∘ f) :=
   rfl
 #align with_top.map_to_dual WithTop.map_toDual
+-/
 
+#print WithTop.map_ofDual /-
 theorem map_ofDual (f : α → β) (a : WithBot αᵒᵈ) : map f (WithBot.ofDual a) = a.map (ofDual ∘ f) :=
   rfl
 #align with_top.map_of_dual WithTop.map_ofDual
+-/
 
+#print WithTop.toDual_map /-
 theorem toDual_map (f : α → β) (a : WithTop α) :
     WithTop.toDual (map f a) = WithBot.map (toDual ∘ f ∘ ofDual) a.toDual :=
   rfl
 #align with_top.to_dual_map WithTop.toDual_map
+-/
 
+#print WithTop.ofDual_map /-
 theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithTop αᵒᵈ) :
     WithTop.ofDual (map f a) = WithBot.map (ofDual ∘ f ∘ toDual) a.ofDual :=
   rfl
 #align with_top.of_dual_map WithTop.ofDual_map
+-/
 
 #print WithTop.ne_top_iff_exists /-
 theorem ne_top_iff_exists {x : WithTop α} : x ≠ ⊤ ↔ ∃ a : α, ↑a = x :=
@@ -919,10 +999,12 @@ theorem toDual_le_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
 #align with_top.to_dual_le_iff WithTop.toDual_le_iff
 -/
 
+#print WithTop.le_toDual_iff /-
 theorem le_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     a ≤ WithTop.toDual b ↔ b ≤ WithBot.ofDual a :=
   Iff.rfl
 #align with_top.le_to_dual_iff WithTop.le_toDual_iff
+-/
 
 #print WithTop.toDual_le_toDual_iff /-
 @[simp]
@@ -938,10 +1020,12 @@ theorem ofDual_le_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
 #align with_top.of_dual_le_iff WithTop.ofDual_le_iff
 -/
 
+#print WithTop.le_ofDual_iff /-
 theorem le_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     a ≤ WithTop.ofDual b ↔ b ≤ WithBot.toDual a :=
   Iff.rfl
 #align with_top.le_of_dual_iff WithTop.le_ofDual_iff
+-/
 
 #print WithTop.ofDual_le_ofDual_iff /-
 @[simp]
@@ -950,20 +1034,26 @@ theorem ofDual_le_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a ≤ Wit
 #align with_top.of_dual_le_of_dual_iff WithTop.ofDual_le_ofDual_iff
 -/
 
+#print WithTop.coe_le_coe /-
 @[simp, norm_cast]
 theorem coe_le_coe : (a : WithTop α) ≤ b ↔ a ≤ b := by
   simp only [← to_dual_le_to_dual_iff, to_dual_apply_coe, WithBot.coe_le_coe, to_dual_le_to_dual]
 #align with_top.coe_le_coe WithTop.coe_le_coe
+-/
 
+#print WithTop.some_le_some /-
 @[simp]
 theorem some_le_some : @LE.le (WithTop α) _ (some a) (some b) ↔ a ≤ b :=
   coe_le_coe
 #align with_top.some_le_some WithTop.some_le_some
+-/
 
+#print WithTop.le_none /-
 @[simp]
 theorem le_none {a : WithTop α} : @LE.le (WithTop α) _ a none :=
   toDual_le_toDual_iff.mp WithBot.none_le
 #align with_top.le_none WithTop.le_none
+-/
 
 instance : OrderTop (WithTop α) :=
   { WithTop.hasTop with le_top := fun a => le_none }
@@ -976,25 +1066,34 @@ instance [OrderBot α] : OrderBot (WithTop α)
 instance [OrderBot α] : BoundedOrder (WithTop α) :=
   { WithTop.orderTop, WithTop.orderBot with }
 
+#print WithTop.not_top_le_coe /-
 theorem not_top_le_coe (a : α) : ¬(⊤ : WithTop α) ≤ ↑a :=
   WithBot.not_coe_le_bot (toDual a)
 #align with_top.not_top_le_coe WithTop.not_top_le_coe
+-/
 
+#print WithTop.le_coe /-
 theorem le_coe : ∀ {o : Option α}, a ∈ o → (@LE.le (WithTop α) _ o b ↔ a ≤ b)
   | _, rfl => coe_le_coe
 #align with_top.le_coe WithTop.le_coe
+-/
 
+#print WithTop.le_coe_iff /-
 theorem le_coe_iff {x : WithTop α} : x ≤ b ↔ ∃ a : α, x = a ∧ a ≤ b := by
   simpa [← to_dual_le_to_dual_iff, WithBot.coe_le_iff]
 #align with_top.le_coe_iff WithTop.le_coe_iff
+-/
 
+#print WithTop.coe_le_iff /-
 theorem coe_le_iff {x : WithTop α} : ↑a ≤ x ↔ ∀ b, x = ↑b → a ≤ b :=
   by
   simp only [← to_dual_le_to_dual_iff, to_dual_apply_coe, WithBot.le_coe_iff, OrderDual.forall,
     to_dual_le_to_dual]
   exact forall₂_congr fun _ _ => Iff.rfl
 #align with_top.coe_le_iff WithTop.coe_le_iff
+-/
 
+#print IsMin.withTop /-
 protected theorem IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) :=
   by
   -- defeq to is_max_to_dual_iff.mp (is_max.with_bot _), but that breaks API boundary
@@ -1002,6 +1101,7 @@ protected theorem IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) :=
   rw [← to_dual_le_to_dual_iff] at hb 
   simpa [to_dual_le_iff] using (IsMax.withBot h : IsMax (to_dual a : WithBot αᵒᵈ)) hb
 #align is_min.with_top IsMin.withTop
+-/
 
 end LE
 
@@ -1012,35 +1112,47 @@ variable [LT α]
 instance (priority := 10) : LT (WithTop α) :=
   ⟨fun o₁ o₂ : Option α => ∃ b ∈ o₁, ∀ a ∈ o₂, b < a⟩
 
+#print WithTop.toDual_lt_iff /-
 theorem toDual_lt_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
     WithTop.toDual a < b ↔ WithBot.ofDual b < a :=
   Iff.rfl
 #align with_top.to_dual_lt_iff WithTop.toDual_lt_iff
+-/
 
+#print WithTop.lt_toDual_iff /-
 theorem lt_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     a < WithTop.toDual b ↔ b < WithBot.ofDual a :=
   Iff.rfl
 #align with_top.lt_to_dual_iff WithTop.lt_toDual_iff
+-/
 
+#print WithTop.toDual_lt_toDual_iff /-
 @[simp]
 theorem toDual_lt_toDual_iff {a b : WithTop α} : WithTop.toDual a < WithTop.toDual b ↔ b < a :=
   Iff.rfl
 #align with_top.to_dual_lt_to_dual_iff WithTop.toDual_lt_toDual_iff
+-/
 
+#print WithTop.ofDual_lt_iff /-
 theorem ofDual_lt_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
     WithTop.ofDual a < b ↔ WithBot.toDual b < a :=
   Iff.rfl
 #align with_top.of_dual_lt_iff WithTop.ofDual_lt_iff
+-/
 
+#print WithTop.lt_ofDual_iff /-
 theorem lt_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     a < WithTop.ofDual b ↔ b < WithBot.toDual a :=
   Iff.rfl
 #align with_top.lt_of_dual_iff WithTop.lt_ofDual_iff
+-/
 
+#print WithTop.ofDual_lt_ofDual_iff /-
 @[simp]
 theorem ofDual_lt_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a < WithTop.ofDual b ↔ b < a :=
   Iff.rfl
 #align with_top.of_dual_lt_of_dual_iff WithTop.ofDual_lt_ofDual_iff
+-/
 
 end LT
 
@@ -1092,34 +1204,44 @@ theorem ofDual_apply_coe (a : αᵒᵈ) : WithBot.ofDual (a : WithBot αᵒᵈ)
 #align with_bot.of_dual_apply_coe WithBot.ofDual_apply_coe
 -/
 
+#print WithBot.map_toDual /-
 theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithTop α) :
     WithBot.map f (WithTop.toDual a) = a.map (toDual ∘ f) :=
   rfl
 #align with_bot.map_to_dual WithBot.map_toDual
+-/
 
+#print WithBot.map_ofDual /-
 theorem map_ofDual (f : α → β) (a : WithTop αᵒᵈ) :
     WithBot.map f (WithTop.ofDual a) = a.map (ofDual ∘ f) :=
   rfl
 #align with_bot.map_of_dual WithBot.map_ofDual
+-/
 
+#print WithBot.toDual_map /-
 theorem toDual_map (f : α → β) (a : WithBot α) :
     WithBot.toDual (WithBot.map f a) = map (toDual ∘ f ∘ ofDual) a.toDual :=
   rfl
 #align with_bot.to_dual_map WithBot.toDual_map
+-/
 
+#print WithBot.ofDual_map /-
 theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithBot αᵒᵈ) :
     WithBot.ofDual (WithBot.map f a) = map (ofDual ∘ f ∘ toDual) a.ofDual :=
   rfl
 #align with_bot.of_dual_map WithBot.ofDual_map
+-/
 
 section LE
 
 variable [LE α] {a b : α}
 
+#print WithBot.toDual_le_iff /-
 theorem toDual_le_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     WithBot.toDual a ≤ b ↔ WithTop.ofDual b ≤ a :=
   Iff.rfl
 #align with_bot.to_dual_le_iff WithBot.toDual_le_iff
+-/
 
 #print WithBot.le_toDual_iff /-
 theorem le_toDual_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
@@ -1135,10 +1257,12 @@ theorem toDual_le_toDual_iff {a b : WithBot α} : WithBot.toDual a ≤ WithBot.t
 #align with_bot.to_dual_le_to_dual_iff WithBot.toDual_le_toDual_iff
 -/
 
+#print WithBot.ofDual_le_iff /-
 theorem ofDual_le_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     WithBot.ofDual a ≤ b ↔ WithTop.toDual b ≤ a :=
   Iff.rfl
 #align with_bot.of_dual_le_iff WithBot.ofDual_le_iff
+-/
 
 #print WithBot.le_ofDual_iff /-
 theorem le_ofDual_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
@@ -1160,35 +1284,47 @@ section LT
 
 variable [LT α] {a b : α}
 
+#print WithBot.toDual_lt_iff /-
 theorem toDual_lt_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     WithBot.toDual a < b ↔ WithTop.ofDual b < a :=
   Iff.rfl
 #align with_bot.to_dual_lt_iff WithBot.toDual_lt_iff
+-/
 
+#print WithBot.lt_toDual_iff /-
 theorem lt_toDual_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
     a < WithBot.toDual b ↔ b < WithTop.ofDual a :=
   Iff.rfl
 #align with_bot.lt_to_dual_iff WithBot.lt_toDual_iff
+-/
 
+#print WithBot.toDual_lt_toDual_iff /-
 @[simp]
 theorem toDual_lt_toDual_iff {a b : WithBot α} : WithBot.toDual a < WithBot.toDual b ↔ b < a :=
   Iff.rfl
 #align with_bot.to_dual_lt_to_dual_iff WithBot.toDual_lt_toDual_iff
+-/
 
+#print WithBot.ofDual_lt_iff /-
 theorem ofDual_lt_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     WithBot.ofDual a < b ↔ WithTop.toDual b < a :=
   Iff.rfl
 #align with_bot.of_dual_lt_iff WithBot.ofDual_lt_iff
+-/
 
+#print WithBot.lt_ofDual_iff /-
 theorem lt_ofDual_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
     a < WithBot.ofDual b ↔ b < WithTop.toDual a :=
   Iff.rfl
 #align with_bot.lt_of_dual_iff WithBot.lt_ofDual_iff
+-/
 
+#print WithBot.ofDual_lt_ofDual_iff /-
 @[simp]
 theorem ofDual_lt_ofDual_iff {a b : WithBot αᵒᵈ} : WithBot.ofDual a < WithBot.ofDual b ↔ b < a :=
   Iff.rfl
 #align with_bot.of_dual_lt_of_dual_iff WithBot.ofDual_lt_ofDual_iff
+-/
 
 end LT
 
@@ -1202,50 +1338,66 @@ variable [LT α] {a b : α}
 
 open OrderDual
 
+#print WithTop.coe_lt_coe /-
 @[simp, norm_cast]
 theorem coe_lt_coe : (a : WithTop α) < b ↔ a < b := by
   simp only [← to_dual_lt_to_dual_iff, to_dual_apply_coe, WithBot.coe_lt_coe, to_dual_lt_to_dual]
 #align with_top.coe_lt_coe WithTop.coe_lt_coe
+-/
 
+#print WithTop.some_lt_some /-
 @[simp]
 theorem some_lt_some : @LT.lt (WithTop α) _ (some a) (some b) ↔ a < b :=
   coe_lt_coe
 #align with_top.some_lt_some WithTop.some_lt_some
+-/
 
+#print WithTop.coe_lt_top /-
 theorem coe_lt_top (a : α) : (a : WithTop α) < ⊤ := by
   simpa [← to_dual_lt_to_dual_iff] using WithBot.bot_lt_coe _
 #align with_top.coe_lt_top WithTop.coe_lt_top
+-/
 
+#print WithTop.some_lt_none /-
 @[simp]
 theorem some_lt_none (a : α) : @LT.lt (WithTop α) _ (some a) none :=
   coe_lt_top a
 #align with_top.some_lt_none WithTop.some_lt_none
+-/
 
+#print WithTop.not_none_lt /-
 @[simp]
 theorem not_none_lt (a : WithTop α) : ¬@LT.lt (WithTop α) _ none a :=
   by
   rw [← to_dual_lt_to_dual_iff]
   exact WithBot.not_lt_none _
 #align with_top.not_none_lt WithTop.not_none_lt
+-/
 
+#print WithTop.lt_iff_exists_coe /-
 theorem lt_iff_exists_coe {a b : WithTop α} : a < b ↔ ∃ p : α, a = p ∧ ↑p < b :=
   by
   rw [← to_dual_lt_to_dual_iff, WithBot.lt_iff_exists_coe, OrderDual.exists]
   exact exists_congr fun _ => and_congr_left' Iff.rfl
 #align with_top.lt_iff_exists_coe WithTop.lt_iff_exists_coe
+-/
 
+#print WithTop.coe_lt_iff /-
 theorem coe_lt_iff {x : WithTop α} : ↑a < x ↔ ∀ b, x = ↑b → a < b :=
   by
   simp only [← to_dual_lt_to_dual_iff, WithBot.lt_coe_iff, to_dual_apply_coe, OrderDual.forall,
     to_dual_lt_to_dual]
   exact forall₂_congr fun _ _ => Iff.rfl
 #align with_top.coe_lt_iff WithTop.coe_lt_iff
+-/
 
+#print WithTop.lt_top_iff_ne_top /-
 /-- A version of `lt_top_iff_ne_top` for `with_top` that only requires `has_lt α`, not
 `partial_order α`. -/
 protected theorem lt_top_iff_ne_top {x : WithTop α} : x < ⊤ ↔ x ≠ ⊤ :=
   @WithBot.bot_lt_iff_ne_bot αᵒᵈ _ x
 #align with_top.lt_top_iff_ne_top WithTop.lt_top_iff_ne_top
+-/
 
 end LT
 
@@ -1272,6 +1424,7 @@ theorem coe_mono [Preorder α] : Monotone (coe : α → WithTop α) := fun a b =
 #align with_top.coe_mono WithTop.coe_mono
 -/
 
+#print WithTop.monotone_iff /-
 theorem monotone_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
     Monotone f ↔ Monotone (f ∘ coe : α → β) ∧ ∀ x : α, f x ≤ f ⊤ :=
   ⟨fun h => ⟨h.comp WithTop.coe_mono, fun x => h le_top⟩, fun h =>
@@ -1279,16 +1432,20 @@ theorem monotone_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
       ⟨WithTop.forall.2 ⟨fun _ => le_rfl, fun x h => (not_top_le_coe _ h).elim⟩, fun x =>
         WithTop.forall.2 ⟨fun _ => h.2 x, fun y hle => h.1 (coe_le_coe.1 hle)⟩⟩⟩
 #align with_top.monotone_iff WithTop.monotone_iff
+-/
 
+#print WithTop.monotone_map_iff /-
 @[simp]
 theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
     Monotone (WithTop.map f) ↔ Monotone f :=
   monotone_iff.trans <| by simp [Monotone]
 #align with_top.monotone_map_iff WithTop.monotone_map_iff
+-/
 
 alias monotone_map_iff ↔ _ _root_.monotone.with_top_map
 #align monotone.with_top_map Monotone.withTop_map
 
+#print WithTop.strictMono_iff /-
 theorem strictMono_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
     StrictMono f ↔ StrictMono (f ∘ coe : α → β) ∧ ∀ x : α, f x < f ⊤ :=
   ⟨fun h => ⟨h.comp WithTop.coe_strictMono, fun x => h (coe_lt_top _)⟩, fun h =>
@@ -1296,16 +1453,20 @@ theorem strictMono_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
       ⟨WithTop.forall.2 ⟨flip absurd (lt_irrefl _), fun x h => (not_top_lt h).elim⟩, fun x =>
         WithTop.forall.2 ⟨fun _ => h.2 x, fun y hle => h.1 (coe_lt_coe.1 hle)⟩⟩⟩
 #align with_top.strict_mono_iff WithTop.strictMono_iff
+-/
 
+#print WithTop.strictMono_map_iff /-
 @[simp]
 theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
     StrictMono (WithTop.map f) ↔ StrictMono f :=
   strictMono_iff.trans <| by simp [StrictMono, coe_lt_top]
 #align with_top.strict_mono_map_iff WithTop.strictMono_map_iff
+-/
 
 alias strict_mono_map_iff ↔ _ _root_.strict_mono.with_top_map
 #align strict_mono.with_top_map StrictMono.withTop_map
 
+#print WithTop.map_le_iff /-
 theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (a b : WithTop α)
     (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) : a.map f ≤ b.map f ↔ a ≤ b :=
   by
@@ -1313,6 +1474,7 @@ theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (a b : WithTop α
     to_dual_le_to_dual_iff]
   simp [mono_iff]
 #align with_top.map_le_iff WithTop.map_le_iff
+-/
 
 instance [SemilatticeInf α] : SemilatticeInf (WithTop α) :=
   { WithTop.partialOrder with
@@ -1328,9 +1490,11 @@ instance [SemilatticeInf α] : SemilatticeInf (WithTop α) :=
         simp at h₂ 
         exact ⟨d, rfl, le_inf h₁' h₂⟩ }
 
+#print WithTop.coe_inf /-
 theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithTop α) = a ⊓ b :=
   rfl
 #align with_top.coe_inf WithTop.coe_inf
+-/
 
 instance [SemilatticeSup α] : SemilatticeSup (WithTop α) :=
   { WithTop.partialOrder with
@@ -1349,9 +1513,11 @@ instance [SemilatticeSup α] : SemilatticeSup (WithTop α) :=
       rcases h₂ a rfl with ⟨c, ⟨⟩, ac⟩
       exact ⟨_, rfl, sup_le ab ac⟩ }
 
+#print WithTop.coe_sup /-
 theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithTop α) = a ⊔ b :=
   rfl
 #align with_top.coe_sup WithTop.coe_sup
+-/
 
 instance [Lattice α] : Lattice (WithTop α) :=
   { WithTop.semilatticeSup, WithTop.semilatticeInf with }
@@ -1366,30 +1532,40 @@ instance [DistribLattice α] : DistribLattice (WithTop α) :=
       | (a₁ : α), (a₂ : α), ⊤ => le_rfl
       | (a₁ : α), (a₂ : α), (a₃ : α) => coe_le_coe.mpr le_sup_inf }
 
+#print WithTop.decidableLE /-
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithTop α) (· ≤ ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLE _ _) toDual_le_toDual_iff
 #align with_top.decidable_le WithTop.decidableLE
+-/
 
+#print WithTop.decidableLT /-
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithTop α) (· < ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLT _ _) toDual_lt_toDual_iff
 #align with_top.decidable_lt WithTop.decidableLT
+-/
 
+#print WithTop.isTotal_le /-
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) :=
   ⟨fun _ _ => by simp_rw [← to_dual_le_to_dual_iff]; exact total_of _ _ _⟩
 #align with_top.is_total_le WithTop.isTotal_le
+-/
 
 instance [LinearOrder α] : LinearOrder (WithTop α) :=
   Lattice.toLinearOrder _
 
+#print WithTop.coe_min /-
 @[simp, norm_cast]
 theorem coe_min [LinearOrder α] (x y : α) : (↑(min x y) : WithTop α) = min x y :=
   rfl
 #align with_top.coe_min WithTop.coe_min
+-/
 
+#print WithTop.coe_max /-
 @[simp, norm_cast]
 theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max x y :=
   rfl
 #align with_top.coe_max WithTop.coe_max
+-/
 
 #print WithTop.wellFounded_lt /-
 theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -359,7 +359,7 @@ instance [Preorder α] : Preorder (WithBot α)
     where
   le := (· ≤ ·)
   lt := (· < ·)
-  lt_iff_le_not_le := by intros ;
+  lt_iff_le_not_le := by intros;
     cases a <;> cases b <;> simp [lt_iff_le_not_le] <;> simp [(· < ·), (· ≤ ·)]
   le_refl o a ha := ⟨a, ha, le_rfl⟩
   le_trans o₁ o₂ o₃ h₁ h₂ a ha :=
@@ -457,7 +457,7 @@ instance [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
       · exact h₂ a rfl
       · exact h₁ a rfl
       · rcases h₁ b rfl with ⟨d, ⟨⟩, h₁'⟩
-        simp at h₂
+        simp at h₂ 
         exact ⟨d, rfl, sup_le h₁' h₂⟩ }
 
 theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithBot α) = a ⊔ b :=
@@ -999,7 +999,7 @@ protected theorem IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) :=
   by
   -- defeq to is_max_to_dual_iff.mp (is_max.with_bot _), but that breaks API boundary
   intro _ hb
-  rw [← to_dual_le_to_dual_iff] at hb
+  rw [← to_dual_le_to_dual_iff] at hb 
   simpa [to_dual_le_iff] using (IsMax.withBot h : IsMax (to_dual a : WithBot αᵒᵈ)) hb
 #align is_min.with_top IsMin.withTop
 
@@ -1325,7 +1325,7 @@ instance [SemilatticeInf α] : SemilatticeInf (WithTop α) :=
       · exact h₂ a rfl
       · exact h₁ a rfl
       · rcases h₁ b rfl with ⟨d, ⟨⟩, h₁'⟩
-        simp at h₂
+        simp at h₂ 
         exact ⟨d, rfl, le_inf h₁' h₂⟩ }
 
 theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithTop α) = a ⊓ b :=

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -428,10 +428,12 @@ theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {
   | (a : α), (b : α) => by simpa only [map_coe, coe_le_coe] using mono_iff
 #align with_bot.map_le_iff WithBot.map_le_iff
 
+#print WithBot.le_coe_unbot' /-
 theorem le_coe_unbot' [Preorder α] : ∀ (a : WithBot α) (b : α), a ≤ a.unbot' b
   | (a : α), b => le_rfl
   | ⊥, b => bot_le
 #align with_bot.le_coe_unbot' WithBot.le_coe_unbot'
+-/
 
 theorem unbot'_bot_le_iff [LE α] [OrderBot α] {a : WithBot α} {b : α} : a.unbot' ⊥ ≤ b ↔ a ≤ b := by
   cases a <;> simp [none_eq_bot, some_eq_coe]
@@ -535,6 +537,7 @@ theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = ma
   rfl
 #align with_bot.coe_max WithBot.coe_max
 
+#print WithBot.wellFounded_lt /-
 theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithBot α) (· < ·) :=
   have acc_bot : Acc ((· < ·) : WithBot α → WithBot α → Prop) ⊥ :=
@@ -554,6 +557,7 @@ theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
                 Option.recOn c (fun _ => acc_bot) fun c hc =>
                   ih _ (some_lt_some.1 hc) (lt_trans hc hba))⟩
 #align with_bot.well_founded_lt WithBot.wellFounded_lt
+-/
 
 instance [LT α] [DenselyOrdered α] [NoMinOrder α] : DenselyOrdered (WithBot α) :=
   ⟨fun a b =>
@@ -566,6 +570,7 @@ instance [LT α] [DenselyOrdered α] [NoMinOrder α] : DenselyOrdered (WithBot 
       let ⟨a, ha₁, ha₂⟩ := exists_between (coe_lt_coe.1 h)
       ⟨a, coe_lt_coe.2 ha₁, coe_lt_coe.2 ha₂⟩⟩
 
+#print WithBot.lt_iff_exists_coe_btwn /-
 theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMinOrder α] {a b : WithBot α} :
     a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b :=
   ⟨fun h =>
@@ -574,6 +579,7 @@ theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMinOrder α]
     ⟨x, hx.1 ▸ hy⟩,
     fun ⟨x, hx⟩ => lt_trans hx.1 hx.2⟩
 #align with_bot.lt_iff_exists_coe_btwn WithBot.lt_iff_exists_coe_btwn
+-/
 
 instance [LE α] [NoTopOrder α] [Nonempty α] : NoTopOrder (WithBot α) :=
   ⟨by
@@ -1385,6 +1391,7 @@ theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max
   rfl
 #align with_top.coe_max WithTop.coe_max
 
+#print WithTop.wellFounded_lt /-
 theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithTop α) (· < ·) :=
   have acc_some : ∀ a : α, Acc ((· < ·) : WithTop α → WithTop α → Prop) (some a) := fun a =>
@@ -1402,9 +1409,11 @@ theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
       (Acc.intro _ fun y => Option.recOn y (fun h => (lt_irrefl _ h).elim) fun _ _ => acc_some _)
       acc_some⟩
 #align with_top.well_founded_lt WithTop.wellFounded_lt
+-/
 
 open OrderDual
 
+#print WithTop.wellFounded_gt /-
 theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithTop α) (· > ·) :=
   ⟨fun a =>
@@ -1416,7 +1425,9 @@ theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     induction' ac with _ H IH generalizing a; subst ha
     exact ⟨_, fun a' h => IH a'.toDual (to_dual_lt_to_dual.mpr h) _ rfl⟩⟩
 #align with_top.well_founded_gt WithTop.wellFounded_gt
+-/
 
+#print WithBot.wellFounded_gt /-
 theorem WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithBot α) (· > ·) :=
   ⟨fun a =>
@@ -1428,7 +1439,9 @@ theorem WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     induction' ac with _ H IH generalizing a; subst ha
     exact ⟨_, fun a' h => IH a'.toDual (to_dual_lt_to_dual.mpr h) _ rfl⟩⟩
 #align with_bot.well_founded_gt WithBot.wellFounded_gt
+-/
 
+#print WithTop.trichotomous.lt /-
 instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithTop α) (· < ·) :=
   ⟨by
@@ -1436,11 +1449,15 @@ instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     iterate 3 simp
     simpa [Option.some_inj] using @trichotomous _ (· < ·) _ a b⟩
 #align with_top.trichotomous.lt WithTop.trichotomous.lt
+-/
 
+#print WithTop.IsWellOrder.lt /-
 instance IsWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] : IsWellOrder (WithTop α) (· < ·)
     where wf := wellFounded_lt h.wf
 #align with_top.is_well_order.lt WithTop.IsWellOrder.lt
+-/
 
+#print WithTop.trichotomous.gt /-
 instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     IsTrichotomous (WithTop α) (· > ·) :=
   ⟨by
@@ -1448,34 +1465,46 @@ instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     iterate 3 simp
     simpa [Option.some_inj] using @trichotomous _ (· > ·) _ a b⟩
 #align with_top.trichotomous.gt WithTop.trichotomous.gt
+-/
 
+#print WithTop.IsWellOrder.gt /-
 instance IsWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] : IsWellOrder (WithTop α) (· > ·)
     where wf := wellFounded_gt h.wf
 #align with_top.is_well_order.gt WithTop.IsWellOrder.gt
+-/
 
+#print WithBot.trichotomous.lt /-
 instance WithBot.trichotomous.lt [Preorder α] [h : IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithBot α) (· < ·) :=
   @WithTop.trichotomous.gt αᵒᵈ _ h
 #align with_bot.trichotomous.lt WithBot.trichotomous.lt
+-/
 
+#print WithBot.isWellOrder.lt /-
 instance WithBot.isWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] :
     IsWellOrder (WithBot α) (· < ·) :=
   @WithTop.IsWellOrder.gt αᵒᵈ _ h
 #align with_bot.is_well_order.lt WithBot.isWellOrder.lt
+-/
 
+#print WithBot.trichotomous.gt /-
 instance WithBot.trichotomous.gt [Preorder α] [h : IsTrichotomous α (· > ·)] :
     IsTrichotomous (WithBot α) (· > ·) :=
   @WithTop.trichotomous.lt αᵒᵈ _ h
 #align with_bot.trichotomous.gt WithBot.trichotomous.gt
+-/
 
+#print WithBot.isWellOrder.gt /-
 instance WithBot.isWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] :
     IsWellOrder (WithBot α) (· > ·) :=
   @WithTop.IsWellOrder.lt αᵒᵈ _ h
 #align with_bot.is_well_order.gt WithBot.isWellOrder.gt
+-/
 
 instance [LT α] [DenselyOrdered α] [NoMaxOrder α] : DenselyOrdered (WithTop α) :=
   OrderDual.denselyOrdered (WithBot αᵒᵈ)
 
+#print WithTop.lt_iff_exists_coe_btwn /-
 theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMaxOrder α] {a b : WithTop α} :
     a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b :=
   ⟨fun h =>
@@ -1484,6 +1513,7 @@ theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMaxOrder α]
     ⟨x, hx.1 ▸ hy⟩,
     fun ⟨x, hx⟩ => lt_trans hx.1 hx.2⟩
 #align with_top.lt_iff_exists_coe_btwn WithTop.lt_iff_exists_coe_btwn
+-/
 
 instance [LE α] [NoBotOrder α] [Nonempty α] : NoBotOrder (WithTop α) :=
   OrderDual.noBotOrder (WithBot αᵒᵈ)

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -128,24 +128,12 @@ def recBotCoe {C : WithBot α → Sort _} (h₁ : C ⊥) (h₂ : ∀ a : α, C a
 #align with_bot.rec_bot_coe WithBot.recBotCoe
 -/
 
-/- warning: with_bot.rec_bot_coe_bot -> WithBot.recBotCoe_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (WithBot.{u1} α) -> Sort.{u2}} (d : C (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (f : forall (a : α), C ((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)), Eq.{u2} (C (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.recBotCoe.{u1, u2} α C d f (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) d
-but is expected to have type
-  forall {α : Type.{u2}} {C : (WithBot.{u2} α) -> Sort.{u1}} (d : C (Bot.bot.{u2} (WithBot.{u2} α) (WithBot.bot.{u2} α))) (f : forall (a : α), C (WithBot.some.{u2} α a)), Eq.{u1} (C (Bot.bot.{u2} (WithBot.{u2} α) (WithBot.bot.{u2} α))) (WithBot.recBotCoe.{u2, u1} α C d f (Bot.bot.{u2} (WithBot.{u2} α) (WithBot.bot.{u2} α))) d
-Case conversion may be inaccurate. Consider using '#align with_bot.rec_bot_coe_bot WithBot.recBotCoe_botₓ'. -/
 @[simp]
 theorem recBotCoe_bot {C : WithBot α → Sort _} (d : C ⊥) (f : ∀ a : α, C a) :
     @recBotCoe _ C d f ⊥ = d :=
   rfl
 #align with_bot.rec_bot_coe_bot WithBot.recBotCoe_bot
 
-/- warning: with_bot.rec_bot_coe_coe -> WithBot.recBotCoe_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (WithBot.{u1} α) -> Sort.{u2}} (d : C (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (f : forall (a : α), C ((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)) (x : α), Eq.{u2} (C ((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} α))) x)) (WithBot.recBotCoe.{u1, u2} α C d f ((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} α))) x)) (f x)
-but is expected to have type
-  forall {α : Type.{u2}} {C : (WithBot.{u2} α) -> Sort.{u1}} (d : C (Bot.bot.{u2} (WithBot.{u2} α) (WithBot.bot.{u2} α))) (f : forall (a : α), C (WithBot.some.{u2} α a)) (x : α), Eq.{u1} (C (WithBot.some.{u2} α x)) (WithBot.recBotCoe.{u2, u1} α C d f (WithBot.some.{u2} α x)) (f x)
-Case conversion may be inaccurate. Consider using '#align with_bot.rec_bot_coe_coe WithBot.recBotCoe_coeₓ'. -/
 @[simp]
 theorem recBotCoe_coe {C : WithBot α → Sort _} (d : C ⊥) (f : ∀ a : α, C a) (x : α) :
     @recBotCoe _ C d f ↑x = f x :=
@@ -222,12 +210,6 @@ theorem map_coe (f : α → β) (a : α) : map f a = f a :=
 #align with_bot.map_coe WithBot.map_coe
 -/
 
-/- warning: with_bot.map_comm -> WithBot.map_comm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {f₁ : α -> β} {f₂ : α -> γ} {g₁ : β -> δ} {g₂ : γ -> δ}, (Eq.{max (succ u1) (succ u4)} (α -> δ) (Function.comp.{succ u1, succ u2, succ u4} α β δ g₁ f₁) (Function.comp.{succ u1, succ u3, succ u4} α γ δ g₂ f₂)) -> (forall (a : α), Eq.{succ u4} (WithBot.{u4} δ) (WithBot.map.{u2, u4} β δ g₁ (WithBot.map.{u1, u2} α β f₁ ((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))) (WithBot.map.{u3, u4} γ δ g₂ (WithBot.map.{u1, u3} α γ f₂ ((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))))
-but is expected to have type
-  forall {α : Type.{u4}} {β : Type.{u2}} {γ : Type.{u1}} {δ : Type.{u3}} {f₁ : α -> β} {f₂ : α -> γ} {g₁ : β -> δ} {g₂ : γ -> δ}, (Eq.{max (succ u4) (succ u3)} (α -> δ) (Function.comp.{succ u4, succ u2, succ u3} α β δ g₁ f₁) (Function.comp.{succ u4, succ u1, succ u3} α γ δ g₂ f₂)) -> (forall (a : α), Eq.{succ u3} (WithBot.{u3} δ) (WithBot.map.{u2, u3} β δ g₁ (WithBot.map.{u4, u2} α β f₁ (WithBot.some.{u4} α a))) (WithBot.map.{u1, u3} γ δ g₂ (WithBot.map.{u4, u1} α γ f₂ (WithBot.some.{u4} α a))))
-Case conversion may be inaccurate. Consider using '#align with_bot.map_comm WithBot.map_commₓ'. -/
 theorem map_comm {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂ : γ → δ} (h : g₁ ∘ f₁ = g₂ ∘ f₂)
     (a : α) : map g₁ (map f₁ a) = map g₂ (map f₂ a) :=
   Option.map_comm h _
@@ -274,33 +256,15 @@ variable [LE α]
 instance (priority := 10) : LE (WithBot α) :=
   ⟨fun o₁ o₂ : Option α => ∀ a ∈ o₁, ∃ b ∈ o₂, a ≤ b⟩
 
-/- warning: with_bot.some_le_some -> WithBot.some_le_some is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α], Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1) (Option.some.{u1} α a) (Option.some.{u1} α b)) (LE.le.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α], Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) (Option.some.{u1} α a) (Option.some.{u1} α b)) (LE.le.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align with_bot.some_le_some WithBot.some_le_someₓ'. -/
 @[simp]
 theorem some_le_some : @LE.le (WithBot α) _ (some a) (some b) ↔ a ≤ b := by simp [(· ≤ ·)]
 #align with_bot.some_le_some WithBot.some_le_some
 
-/- warning: with_bot.coe_le_coe -> WithBot.coe_le_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α], Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{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) ((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} α))) b)) (LE.le.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α], Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) (WithBot.some.{u1} α a) (WithBot.some.{u1} α b)) (LE.le.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align with_bot.coe_le_coe WithBot.coe_le_coeₓ'. -/
 @[simp, norm_cast]
 theorem coe_le_coe : (a : WithBot α) ≤ b ↔ a ≤ b :=
   some_le_some
 #align with_bot.coe_le_coe WithBot.coe_le_coe
 
-/- warning: with_bot.none_le -> WithBot.none_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α}, LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1) (Option.none.{u1} α) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α}, LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) (Option.none.{u1} α) a
-Case conversion may be inaccurate. Consider using '#align with_bot.none_le WithBot.none_leₓ'. -/
 @[simp]
 theorem none_le {a : WithBot α} : @LE.le (WithBot α) _ none a := fun b h => Option.noConfusion h
 #align with_bot.none_le WithBot.none_le
@@ -316,55 +280,25 @@ instance [OrderTop α] : OrderTop (WithBot α)
 instance [OrderTop α] : BoundedOrder (WithBot α) :=
   { WithBot.orderTop, WithBot.orderBot with }
 
-/- warning: with_bot.not_coe_le_bot -> WithBot.not_coe_le_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] (a : α), Not (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{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) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] (a : α), Not (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) (WithBot.some.{u1} α a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align with_bot.not_coe_le_bot WithBot.not_coe_le_botₓ'. -/
 theorem not_coe_le_bot (a : α) : ¬(a : WithBot α) ≤ ⊥ := fun h =>
   let ⟨b, hb, _⟩ := h _ rfl
   Option.not_mem_none _ hb
 #align with_bot.not_coe_le_bot WithBot.not_coe_le_bot
 
-/- warning: with_bot.coe_le -> WithBot.coe_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α] {o : Option.{u1} α}, (Membership.Mem.{u1, u1} α (Option.{u1} α) (Option.hasMem.{u1} α) b o) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{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) o) (LE.le.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α] {o : Option.{u1} α}, (Membership.mem.{u1, u1} α (Option.{u1} α) (Option.instMembershipOption.{u1} α) b o) -> (Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) (WithBot.some.{u1} α a) o) (LE.le.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align with_bot.coe_le WithBot.coe_leₓ'. -/
 theorem coe_le : ∀ {o : Option α}, b ∈ o → ((a : WithBot α) ≤ o ↔ a ≤ b)
   | _, rfl => coe_le_coe
 #align with_bot.coe_le WithBot.coe_le
 
-/- warning: with_bot.coe_le_iff -> WithBot.coe_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} [_inst_1 : LE.{u1} α] {x : WithBot.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{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) x) (Exists.{succ u1} α (fun (b : α) => And (Eq.{succ u1} (WithBot.{u1} α) x ((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} α))) b)) (LE.le.{u1} α _inst_1 a b)))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} [_inst_1 : LE.{u1} α] {x : WithBot.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) (WithBot.some.{u1} α a) x) (Exists.{succ u1} α (fun (b : α) => And (Eq.{succ u1} (WithBot.{u1} α) x (WithBot.some.{u1} α b)) (LE.le.{u1} α _inst_1 a b)))
-Case conversion may be inaccurate. Consider using '#align with_bot.coe_le_iff WithBot.coe_le_iffₓ'. -/
 theorem coe_le_iff : ∀ {x : WithBot α}, ↑a ≤ x ↔ ∃ b : α, x = b ∧ a ≤ b
   | some a => by simp [some_eq_coe, coe_eq_coe]
   | none => iff_of_false (not_coe_le_bot _) <| by simp [none_eq_bot]
 #align with_bot.coe_le_iff WithBot.coe_le_iff
 
-/- warning: with_bot.le_coe_iff -> WithBot.le_coe_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {b : α} [_inst_1 : LE.{u1} α] {x : WithBot.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1) x ((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} α))) b)) (forall (a : α), (Eq.{succ u1} (WithBot.{u1} α) x ((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_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} {b : α} [_inst_1 : LE.{u1} α] {x : WithBot.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x (WithBot.some.{u1} α b)) (forall (a : α), (Eq.{succ u1} (WithBot.{u1} α) x (WithBot.some.{u1} α a)) -> (LE.le.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align with_bot.le_coe_iff WithBot.le_coe_iffₓ'. -/
 theorem le_coe_iff : ∀ {x : WithBot α}, x ≤ b ↔ ∀ a, x = ↑a → a ≤ b
   | some b => by simp [some_eq_coe, coe_eq_coe]
   | none => by simp [none_eq_bot]
 #align with_bot.le_coe_iff WithBot.le_coe_iff
 
-/- warning: is_max.with_bot -> IsMax.withBot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} [_inst_1 : LE.{u1} α], (IsMax.{u1} α _inst_1 a) -> (IsMax.{u1} (WithBot.{u1} α) (WithBot.hasLe.{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))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} [_inst_1 : LE.{u1} α], (IsMax.{u1} α _inst_1 a) -> (IsMax.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) (WithBot.some.{u1} α a))
-Case conversion may be inaccurate. Consider using '#align is_max.with_bot IsMax.withBotₓ'. -/
 protected theorem IsMax.withBot (h : IsMax a) : IsMax (a : WithBot α)
   | none, _ => bot_le
   | some b, hb => some_le_some.2 <| h <| some_le_some.1 hb
@@ -379,87 +313,39 @@ variable [LT α]
 instance (priority := 10) : LT (WithBot α) :=
   ⟨fun o₁ o₂ : Option α => ∃ b ∈ o₂, ∀ a ∈ o₁, a < b⟩
 
-/- warning: with_bot.some_lt_some -> WithBot.some_lt_some is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LT.{u1} α], Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (Option.some.{u1} α a) (Option.some.{u1} α b)) (LT.lt.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LT.{u1} α], Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) (Option.some.{u1} α a) (Option.some.{u1} α b)) (LT.lt.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align with_bot.some_lt_some WithBot.some_lt_someₓ'. -/
 @[simp]
 theorem some_lt_some : @LT.lt (WithBot α) _ (some a) (some b) ↔ a < b := by simp [(· < ·)]
 #align with_bot.some_lt_some WithBot.some_lt_some
 
-/- warning: with_bot.coe_lt_coe -> WithBot.coe_lt_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LT.{u1} α], Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{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) ((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} α))) b)) (LT.lt.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LT.{u1} α], Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) (WithBot.some.{u1} α a) (WithBot.some.{u1} α b)) (LT.lt.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align with_bot.coe_lt_coe WithBot.coe_lt_coeₓ'. -/
 @[simp, norm_cast]
 theorem coe_lt_coe : (a : WithBot α) < b ↔ a < b :=
   some_lt_some
 #align with_bot.coe_lt_coe WithBot.coe_lt_coe
 
-/- warning: with_bot.none_lt_some -> WithBot.none_lt_some is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : α), LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (Option.none.{u1} α) (Option.some.{u1} α a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : α), LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) (Option.none.{u1} α) (WithBot.some.{u1} α a)
-Case conversion may be inaccurate. Consider using '#align with_bot.none_lt_some WithBot.none_lt_someₓ'. -/
 @[simp]
 theorem none_lt_some (a : α) : @LT.lt (WithBot α) _ none (some a) :=
   ⟨a, rfl, fun b hb => (Option.not_mem_none _ hb).elim⟩
 #align with_bot.none_lt_some WithBot.none_lt_some
 
-/- warning: with_bot.bot_lt_coe -> WithBot.bot_lt_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : α), LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) ((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)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : α), LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) (WithBot.some.{u1} α a)
-Case conversion may be inaccurate. Consider using '#align with_bot.bot_lt_coe WithBot.bot_lt_coeₓ'. -/
 theorem bot_lt_coe (a : α) : (⊥ : WithBot α) < a :=
   none_lt_some a
 #align with_bot.bot_lt_coe WithBot.bot_lt_coe
 
-/- warning: with_bot.not_lt_none -> WithBot.not_lt_none is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : WithBot.{u1} α), Not (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) a (Option.none.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : WithBot.{u1} α), Not (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) a (Option.none.{u1} α))
-Case conversion may be inaccurate. Consider using '#align with_bot.not_lt_none WithBot.not_lt_noneₓ'. -/
 @[simp]
 theorem not_lt_none (a : WithBot α) : ¬@LT.lt (WithBot α) _ a none := fun ⟨_, h, _⟩ =>
   Option.not_mem_none _ h
 #align with_bot.not_lt_none WithBot.not_lt_none
 
-/- warning: with_bot.lt_iff_exists_coe -> WithBot.lt_iff_exists_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) a b) (Exists.{succ u1} α (fun (p : α) => And (Eq.{succ u1} (WithBot.{u1} α) b ((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} α))) p)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) a ((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} α))) p))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) a b) (Exists.{succ u1} α (fun (p : α) => And (Eq.{succ u1} (WithBot.{u1} α) b (WithBot.some.{u1} α p)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) a (WithBot.some.{u1} α p))))
-Case conversion may be inaccurate. Consider using '#align with_bot.lt_iff_exists_coe WithBot.lt_iff_exists_coeₓ'. -/
 theorem lt_iff_exists_coe : ∀ {a b : WithBot α}, a < b ↔ ∃ p : α, b = p ∧ a < p
   | a, some b => by simp [some_eq_coe, coe_eq_coe]
   | a, none => iff_of_false (not_lt_none _) <| by simp [none_eq_bot]
 #align with_bot.lt_iff_exists_coe WithBot.lt_iff_exists_coe
 
-/- warning: with_bot.lt_coe_iff -> WithBot.lt_coe_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {b : α} [_inst_1 : LT.{u1} α] {x : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) x ((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} α))) b)) (forall (a : α), (Eq.{succ u1} (WithBot.{u1} α) x ((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_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} {b : α} [_inst_1 : LT.{u1} α] {x : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x (WithBot.some.{u1} α b)) (forall (a : WithBot.{u1} α), (Eq.{succ u1} (WithBot.{u1} α) x a) -> (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) a (WithBot.some.{u1} α b)))
-Case conversion may be inaccurate. Consider using '#align with_bot.lt_coe_iff WithBot.lt_coe_iffₓ'. -/
 theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a, x = ↑a → a < b
   | some b => by simp [some_eq_coe, coe_eq_coe, coe_lt_coe]
   | none => by simp [none_eq_bot, bot_lt_coe]
 #align with_bot.lt_coe_iff WithBot.lt_coe_iff
 
-/- warning: with_bot.bot_lt_iff_ne_bot -> WithBot.bot_lt_iff_ne_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {x : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) x) (Ne.{succ u1} (WithBot.{u1} α) x (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {x : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) x) (Ne.{succ u1} (WithBot.{u1} α) x (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align with_bot.bot_lt_iff_ne_bot WithBot.bot_lt_iff_ne_botₓ'. -/
 /-- A version of `bot_lt_iff_ne_bot` for `with_bot` that only requires `has_lt α`, not
 `partial_order α`. -/
 protected theorem bot_lt_iff_ne_bot : ∀ {x : WithBot α}, ⊥ < x ↔ x ≠ ⊥
@@ -501,12 +387,6 @@ theorem coe_mono [Preorder α] : Monotone (coe : α → WithBot α) := fun a b =
 #align with_bot.coe_mono WithBot.coe_mono
 -/
 
-/- warning: with_bot.monotone_iff -> WithBot.monotone_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithBot.{u1} α) -> β}, Iff (Monotone.{u1, u2} (WithBot.{u1} α) β (WithBot.preorder.{u1} α _inst_1) _inst_2 f) (And (Monotone.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithBot.{u1} α) β f ((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} α)))))) (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (f ((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} α))) x))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : (WithBot.{u2} α) -> β}, Iff (Monotone.{u2, u1} (WithBot.{u2} α) β (WithBot.preorder.{u2} α _inst_1) _inst_2 f) (And (Monotone.{u2, u1} α β _inst_1 _inst_2 (fun (a : α) => f (WithBot.some.{u2} α a))) (forall (x : α), LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f (Bot.bot.{u2} (WithBot.{u2} α) (WithBot.bot.{u2} α))) (f (WithBot.some.{u2} α x))))
-Case conversion may be inaccurate. Consider using '#align with_bot.monotone_iff WithBot.monotone_iffₓ'. -/
 theorem monotone_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
     Monotone f ↔ Monotone (f ∘ coe : α → β) ∧ ∀ x : α, f ⊥ ≤ f x :=
   ⟨fun h => ⟨h.comp WithBot.coe_mono, fun x => h bot_le⟩, fun h =>
@@ -515,33 +395,15 @@ theorem monotone_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
         WithBot.forall.2 ⟨fun h => (not_coe_le_bot _ h).elim, fun y hle => h.1 (coe_le_coe.1 hle)⟩⟩⟩
 #align with_bot.monotone_iff WithBot.monotone_iff
 
-/- warning: with_bot.monotone_map_iff -> WithBot.monotone_map_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (Monotone.{u1, u2} (WithBot.{u1} α) (WithBot.{u2} β) (WithBot.preorder.{u1} α _inst_1) (WithBot.preorder.{u2} β _inst_2) (WithBot.map.{u1, u2} α β f)) (Monotone.{u1, u2} α β _inst_1 _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, Iff (Monotone.{u2, u1} (WithBot.{u2} α) (WithBot.{u1} β) (WithBot.preorder.{u2} α _inst_1) (WithBot.preorder.{u1} β _inst_2) (WithBot.map.{u2, u1} α β f)) (Monotone.{u2, u1} α β _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align with_bot.monotone_map_iff WithBot.monotone_map_iffₓ'. -/
 @[simp]
 theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
     Monotone (WithBot.map f) ↔ Monotone f :=
   monotone_iff.trans <| by simp [Monotone]
 #align with_bot.monotone_map_iff WithBot.monotone_map_iff
 
-/- warning: monotone.with_bot_map -> Monotone.withBot_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (Monotone.{u1, u2} (WithBot.{u1} α) (WithBot.{u2} β) (WithBot.preorder.{u1} α _inst_1) (WithBot.preorder.{u2} β _inst_2) (WithBot.map.{u1, u2} α β f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (Monotone.{u2, u1} α β _inst_1 _inst_2 f) -> (Monotone.{u2, u1} (WithBot.{u2} α) (WithBot.{u1} β) (WithBot.preorder.{u2} α _inst_1) (WithBot.preorder.{u1} β _inst_2) (WithBot.map.{u2, u1} α β f))
-Case conversion may be inaccurate. Consider using '#align monotone.with_bot_map Monotone.withBot_mapₓ'. -/
 alias monotone_map_iff ↔ _ _root_.monotone.with_bot_map
 #align monotone.with_bot_map Monotone.withBot_map
 
-/- warning: with_bot.strict_mono_iff -> WithBot.strictMono_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithBot.{u1} α) -> β}, Iff (StrictMono.{u1, u2} (WithBot.{u1} α) β (WithBot.preorder.{u1} α _inst_1) _inst_2 f) (And (StrictMono.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithBot.{u1} α) β f ((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} α)))))) (forall (x : α), LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (f ((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} α))) x))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : (WithBot.{u2} α) -> β}, Iff (StrictMono.{u2, u1} (WithBot.{u2} α) β (WithBot.preorder.{u2} α _inst_1) _inst_2 f) (And (StrictMono.{u2, u1} α β _inst_1 _inst_2 (fun (a : α) => f (WithBot.some.{u2} α a))) (forall (x : α), LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (f (Bot.bot.{u2} (WithBot.{u2} α) (WithBot.bot.{u2} α))) (f (WithBot.some.{u2} α x))))
-Case conversion may be inaccurate. Consider using '#align with_bot.strict_mono_iff WithBot.strictMono_iffₓ'. -/
 theorem strictMono_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
     StrictMono f ↔ StrictMono (f ∘ coe : α → β) ∧ ∀ x : α, f ⊥ < f x :=
   ⟨fun h => ⟨h.comp WithBot.coe_strictMono, fun x => h (bot_lt_coe _)⟩, fun h =>
@@ -550,33 +412,15 @@ theorem strictMono_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
         WithBot.forall.2 ⟨fun h => (not_lt_bot h).elim, fun y hle => h.1 (coe_lt_coe.1 hle)⟩⟩⟩
 #align with_bot.strict_mono_iff WithBot.strictMono_iff
 
-/- warning: with_bot.strict_mono_map_iff -> WithBot.strictMono_map_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (StrictMono.{u1, u2} (WithBot.{u1} α) (WithBot.{u2} β) (WithBot.preorder.{u1} α _inst_1) (WithBot.preorder.{u2} β _inst_2) (WithBot.map.{u1, u2} α β f)) (StrictMono.{u1, u2} α β _inst_1 _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, Iff (StrictMono.{u2, u1} (WithBot.{u2} α) (WithBot.{u1} β) (WithBot.preorder.{u2} α _inst_1) (WithBot.preorder.{u1} β _inst_2) (WithBot.map.{u2, u1} α β f)) (StrictMono.{u2, u1} α β _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align with_bot.strict_mono_map_iff WithBot.strictMono_map_iffₓ'. -/
 @[simp]
 theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
     StrictMono (WithBot.map f) ↔ StrictMono f :=
   strictMono_iff.trans <| by simp [StrictMono, bot_lt_coe]
 #align with_bot.strict_mono_map_iff WithBot.strictMono_map_iff
 
-/- warning: strict_mono.with_bot_map -> StrictMono.withBot_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictMono.{u1, u2} (WithBot.{u1} α) (WithBot.{u2} β) (WithBot.preorder.{u1} α _inst_1) (WithBot.preorder.{u2} β _inst_2) (WithBot.map.{u1, u2} α β f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (StrictMono.{u2, u1} α β _inst_1 _inst_2 f) -> (StrictMono.{u2, u1} (WithBot.{u2} α) (WithBot.{u1} β) (WithBot.preorder.{u2} α _inst_1) (WithBot.preorder.{u1} β _inst_2) (WithBot.map.{u2, u1} α β f))
-Case conversion may be inaccurate. Consider using '#align strict_mono.with_bot_map StrictMono.withBot_mapₓ'. -/
 alias strict_mono_map_iff ↔ _ _root_.strict_mono.with_bot_map
 #align strict_mono.with_bot_map StrictMono.withBot_map
 
-/- warning: with_bot.map_le_iff -> WithBot.map_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β), (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)) -> (forall (a : WithBot.{u1} α) (b : WithBot.{u1} α), Iff (LE.le.{u2} (WithBot.{u2} β) (Preorder.toHasLe.{u2} (WithBot.{u2} β) (WithBot.preorder.{u2} β _inst_2)) (WithBot.map.{u1, u2} α β f a) (WithBot.map.{u1, u2} α β f b)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] (f : α -> β), (forall {a : α} {b : α}, Iff (LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f a) (f b)) (LE.le.{u2} α (Preorder.toLE.{u2} α _inst_1) a b)) -> (forall (a : WithBot.{u2} α) (b : WithBot.{u2} α), Iff (LE.le.{u1} (WithBot.{u1} β) (Preorder.toLE.{u1} (WithBot.{u1} β) (WithBot.preorder.{u1} β _inst_2)) (WithBot.map.{u2, u1} α β f a) (WithBot.map.{u2, u1} α β f b)) (LE.le.{u2} (WithBot.{u2} α) (Preorder.toLE.{u2} (WithBot.{u2} α) (WithBot.preorder.{u2} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align with_bot.map_le_iff WithBot.map_le_iffₓ'. -/
 theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
     ∀ a b : WithBot α, a.map f ≤ b.map f ↔ a ≤ b
   | ⊥, _ => by simp only [map_bot, bot_le]
@@ -584,33 +428,15 @@ theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {
   | (a : α), (b : α) => by simpa only [map_coe, coe_le_coe] using mono_iff
 #align with_bot.map_le_iff WithBot.map_le_iff
 
-/- warning: with_bot.le_coe_unbot' -> WithBot.le_coe_unbot' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : WithBot.{u1} α) (b : α), LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a ((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} α))) (WithBot.unbot'.{u1} α b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : WithBot.{u1} α) (b : α), LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a (WithBot.some.{u1} α (WithBot.unbot'.{u1} α b a))
-Case conversion may be inaccurate. Consider using '#align with_bot.le_coe_unbot' WithBot.le_coe_unbot'ₓ'. -/
 theorem le_coe_unbot' [Preorder α] : ∀ (a : WithBot α) (b : α), a ≤ a.unbot' b
   | (a : α), b => le_rfl
   | ⊥, b => bot_le
 #align with_bot.le_coe_unbot' WithBot.le_coe_unbot'
 
-/- warning: with_bot.unbot'_bot_le_iff -> WithBot.unbot'_bot_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : OrderBot.{u1} α _inst_1] {a : WithBot.{u1} α} {b : α}, Iff (LE.le.{u1} α _inst_1 (WithBot.unbot'.{u1} α (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α _inst_1 _inst_2)) a) b) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1) a ((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} α))) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : OrderBot.{u1} α _inst_1] {a : WithBot.{u1} α} {b : α}, Iff (LE.le.{u1} α _inst_1 (WithBot.unbot'.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α _inst_1 _inst_2)) a) b) (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) a (WithBot.some.{u1} α b))
-Case conversion may be inaccurate. Consider using '#align with_bot.unbot'_bot_le_iff WithBot.unbot'_bot_le_iffₓ'. -/
 theorem unbot'_bot_le_iff [LE α] [OrderBot α] {a : WithBot α} {b : α} : a.unbot' ⊥ ≤ b ↔ a ≤ b := by
   cases a <;> simp [none_eq_bot, some_eq_coe]
 #align with_bot.unbot'_bot_le_iff WithBot.unbot'_bot_le_iff
 
-/- warning: with_bot.unbot'_lt_iff -> WithBot.unbot'_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : α} {c : α}, (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Iff (LT.lt.{u1} α _inst_1 (WithBot.unbot'.{u1} α b a) c) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) a ((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} α))) c)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : α} {c : α}, (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Iff (LT.lt.{u1} α _inst_1 (WithBot.unbot'.{u1} α b a) c) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) a (WithBot.some.{u1} α c)))
-Case conversion may be inaccurate. Consider using '#align with_bot.unbot'_lt_iff WithBot.unbot'_lt_iffₓ'. -/
 theorem unbot'_lt_iff [LT α] {a : WithBot α} {b c : α} (ha : a ≠ ⊥) : a.unbot' b < c ↔ a < c :=
   by
   lift a to α using ha
@@ -632,12 +458,6 @@ instance [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
         simp at h₂
         exact ⟨d, rfl, sup_le h₁' h₂⟩ }
 
-/- warning: with_bot.coe_sup -> WithBot.coe_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithBot.{u1} α) ((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} α))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b)) (Sup.sup.{u1} (WithBot.{u1} α) (SemilatticeSup.toHasSup.{u1} (WithBot.{u1} α) (WithBot.semilatticeSup.{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) ((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} α))) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b)) (Sup.sup.{u1} (WithBot.{u1} α) (SemilatticeSup.toSup.{u1} (WithBot.{u1} α) (WithBot.semilatticeSup.{u1} α _inst_1)) (WithBot.some.{u1} α a) (WithBot.some.{u1} α b))
-Case conversion may be inaccurate. Consider using '#align with_bot.coe_sup WithBot.coe_supₓ'. -/
 theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithBot α) = a ⊔ b :=
   rfl
 #align with_bot.coe_sup WithBot.coe_sup
@@ -660,12 +480,6 @@ instance [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
       rcases h₂ a rfl with ⟨c, ⟨⟩, ac⟩
       exact ⟨_, rfl, le_inf ab ac⟩ }
 
-/- warning: with_bot.coe_inf -> WithBot.coe_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithBot.{u1} α) ((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} α))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b)) (Inf.inf.{u1} (WithBot.{u1} α) (SemilatticeInf.toHasInf.{u1} (WithBot.{u1} α) (WithBot.semilatticeInf.{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) ((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} α))) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b)) (Inf.inf.{u1} (WithBot.{u1} α) (SemilatticeInf.toInf.{u1} (WithBot.{u1} α) (WithBot.semilatticeInf.{u1} α _inst_1)) (WithBot.some.{u1} α a) (WithBot.some.{u1} α b))
-Case conversion may be inaccurate. Consider using '#align with_bot.coe_inf WithBot.coe_infₓ'. -/
 theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithBot α) = a ⊓ b :=
   rfl
 #align with_bot.coe_inf WithBot.coe_inf
@@ -686,36 +500,18 @@ instance [DistribLattice α] : DistribLattice (WithBot α) :=
       | (a₁ : α), (a₂ : α), ⊥ => inf_le_right
       | (a₁ : α), (a₂ : α), (a₃ : α) => coe_le_coe.mpr le_sup_inf }
 
-/- warning: with_bot.decidable_le -> WithBot.decidableLE is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4222 : α) (x._@.Mathlib.Order.WithBot._hyg.4224 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4222 x._@.Mathlib.Order.WithBot._hyg.4224)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4242 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4244 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4242 x._@.Mathlib.Order.WithBot._hyg.4244)
-Case conversion may be inaccurate. Consider using '#align with_bot.decidable_le WithBot.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
   | none, x => isTrue fun a h => Option.noConfusion h
   | some x, some y => if h : x ≤ y then isTrue (some_le_some.2 h) else isFalse <| by simp [*]
   | some x, none => isFalse fun h => by rcases h x rfl with ⟨y, ⟨_⟩, _⟩
 #align with_bot.decidable_le WithBot.decidableLE
 
-/- warning: with_bot.decidable_lt -> WithBot.decidableLT is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4385 : α) (x._@.Mathlib.Order.WithBot._hyg.4387 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4385 x._@.Mathlib.Order.WithBot._hyg.4387)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4405 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4407 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4405 x._@.Mathlib.Order.WithBot._hyg.4407)
-Case conversion may be inaccurate. Consider using '#align with_bot.decidable_lt WithBot.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
   | none, some x => isTrue <| by exists x, rfl <;> rintro _ ⟨⟩
   | some x, some y => if h : x < y then isTrue <| by simp [*] else isFalse <| by simp [*]
   | x, none => isFalse <| by rintro ⟨a, ⟨⟨⟩⟩⟩
 #align with_bot.decidable_lt WithBot.decidableLT
 
-/- warning: with_bot.is_total_le -> WithBot.isTotal_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4585 : α) (x._@.Mathlib.Order.WithBot._hyg.4587 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4585 x._@.Mathlib.Order.WithBot._hyg.4587)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4605 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4607 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4605 x._@.Mathlib.Order.WithBot._hyg.4607)
-Case conversion may be inaccurate. Consider using '#align with_bot.is_total_le WithBot.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithBot α) (· ≤ ·) :=
   ⟨fun a b =>
     match a, b with
@@ -727,36 +523,18 @@ instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithBot α) (·
 instance [LinearOrder α] : LinearOrder (WithBot α) :=
   Lattice.toLinearOrder _
 
-/- warning: with_bot.coe_min -> WithBot.coe_min is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (x : α) (y : α), Eq.{succ u1} (WithBot.{u1} α) ((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} α))) (LinearOrder.min.{u1} α _inst_1 x y)) (LinearOrder.min.{u1} (WithBot.{u1} α) (WithBot.linearOrder.{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} α))) x) ((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} α))) y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (x : α) (y : α), Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) x y)) (Min.min.{u1} (WithBot.{u1} α) (LinearOrder.toMin.{u1} (WithBot.{u1} α) (WithBot.linearOrder.{u1} α _inst_1)) (WithBot.some.{u1} α x) (WithBot.some.{u1} α y))
-Case conversion may be inaccurate. Consider using '#align with_bot.coe_min WithBot.coe_minₓ'. -/
 -- this is not marked simp because the corresponding with_top lemmas are used
 @[norm_cast]
 theorem coe_min [LinearOrder α] (x y : α) : ((min x y : α) : WithBot α) = min x y :=
   rfl
 #align with_bot.coe_min WithBot.coe_min
 
-/- warning: with_bot.coe_max -> WithBot.coe_max is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (x : α) (y : α), Eq.{succ u1} (WithBot.{u1} α) ((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} α))) (LinearOrder.max.{u1} α _inst_1 x y)) (LinearOrder.max.{u1} (WithBot.{u1} α) (WithBot.linearOrder.{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} α))) x) ((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} α))) y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (x : α) (y : α), Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) x y)) (Max.max.{u1} (WithBot.{u1} α) (LinearOrder.toMax.{u1} (WithBot.{u1} α) (WithBot.linearOrder.{u1} α _inst_1)) (WithBot.some.{u1} α x) (WithBot.some.{u1} α y))
-Case conversion may be inaccurate. Consider using '#align with_bot.coe_max WithBot.coe_maxₓ'. -/
 -- this is not marked simp because the corresponding with_top lemmas are used
 @[norm_cast]
 theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = max x y :=
   rfl
 #align with_bot.coe_max WithBot.coe_max
 
-/- warning: with_bot.well_founded_lt -> WithBot.wellFounded_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4789 : α) (x._@.Mathlib.Order.WithBot._hyg.4791 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4789 x._@.Mathlib.Order.WithBot._hyg.4791)) -> (WellFounded.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4809 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4811 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.4809 x._@.Mathlib.Order.WithBot._hyg.4811))
-Case conversion may be inaccurate. Consider using '#align with_bot.well_founded_lt WithBot.wellFounded_ltₓ'. -/
 theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithBot α) (· < ·) :=
   have acc_bot : Acc ((· < ·) : WithBot α → WithBot α → Prop) ⊥ :=
@@ -788,12 +566,6 @@ instance [LT α] [DenselyOrdered α] [NoMinOrder α] : DenselyOrdered (WithBot 
       let ⟨a, ha₁, ha₂⟩ := exists_between (coe_lt_coe.1 h)
       ⟨a, coe_lt_coe.2 ha₁, coe_lt_coe.2 ha₂⟩⟩
 
-/- warning: with_bot.lt_iff_exists_coe_btwn -> WithBot.lt_iff_exists_coe_btwn is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DenselyOrdered.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (x : α) => And (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a ((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} α))) x)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{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} α))) x) b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DenselyOrdered.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (x : α) => And (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a (WithBot.some.{u1} α x)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) (WithBot.some.{u1} α x) b)))
-Case conversion may be inaccurate. Consider using '#align with_bot.lt_iff_exists_coe_btwn WithBot.lt_iff_exists_coe_btwnₓ'. -/
 theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMinOrder α] {a b : WithBot α} :
     a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b :=
   ⟨fun h =>
@@ -908,24 +680,12 @@ def recTopCoe {C : WithTop α → Sort _} (h₁ : C ⊤) (h₂ : ∀ a : α, C a
 #align with_top.rec_top_coe WithTop.recTopCoe
 -/
 
-/- warning: with_top.rec_top_coe_top -> WithTop.recTopCoe_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (WithTop.{u1} α) -> Sort.{u2}} (d : C (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (f : forall (a : α), C ((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)), Eq.{u2} (C (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.recTopCoe.{u1, u2} α C d f (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) d
-but is expected to have type
-  forall {α : Type.{u2}} {C : (WithTop.{u2} α) -> Sort.{u1}} (d : C (Top.top.{u2} (WithTop.{u2} α) (WithTop.top.{u2} α))) (f : forall (a : α), C (WithTop.some.{u2} α a)), Eq.{u1} (C (Top.top.{u2} (WithTop.{u2} α) (WithTop.top.{u2} α))) (WithTop.recTopCoe.{u2, u1} α C d f (Top.top.{u2} (WithTop.{u2} α) (WithTop.top.{u2} α))) d
-Case conversion may be inaccurate. Consider using '#align with_top.rec_top_coe_top WithTop.recTopCoe_topₓ'. -/
 @[simp]
 theorem recTopCoe_top {C : WithTop α → Sort _} (d : C ⊤) (f : ∀ a : α, C a) :
     @recTopCoe _ C d f ⊤ = d :=
   rfl
 #align with_top.rec_top_coe_top WithTop.recTopCoe_top
 
-/- warning: with_top.rec_top_coe_coe -> WithTop.recTopCoe_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {C : (WithTop.{u1} α) -> Sort.{u2}} (d : C (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (f : forall (a : α), C ((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)) (x : α), Eq.{u2} (C ((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} α))) x)) (WithTop.recTopCoe.{u1, u2} α C d f ((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} α))) x)) (f x)
-but is expected to have type
-  forall {α : Type.{u2}} {C : (WithTop.{u2} α) -> Sort.{u1}} (d : C (Top.top.{u2} (WithTop.{u2} α) (WithTop.top.{u2} α))) (f : forall (a : α), C (WithTop.some.{u2} α a)) (x : α), Eq.{u1} (C (WithTop.some.{u2} α x)) (WithTop.recTopCoe.{u2, u1} α C d f (WithTop.some.{u2} α x)) (f x)
-Case conversion may be inaccurate. Consider using '#align with_top.rec_top_coe_coe WithTop.recTopCoe_coeₓ'. -/
 @[simp]
 theorem recTopCoe_coe {C : WithTop α → Sort _} (d : C ⊤) (f : ∀ a : α, C a) (x : α) :
     @recTopCoe _ C d f ↑x = f x :=
@@ -1082,55 +842,25 @@ theorem map_coe (f : α → β) (a : α) : map f a = f a :=
 #align with_top.map_coe WithTop.map_coe
 -/
 
-/- warning: with_top.map_comm -> WithTop.map_comm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {f₁ : α -> β} {f₂ : α -> γ} {g₁ : β -> δ} {g₂ : γ -> δ}, (Eq.{max (succ u1) (succ u4)} (α -> δ) (Function.comp.{succ u1, succ u2, succ u4} α β δ g₁ f₁) (Function.comp.{succ u1, succ u3, succ u4} α γ δ g₂ f₂)) -> (forall (a : α), Eq.{succ u4} (WithTop.{u4} δ) (WithTop.map.{u2, u4} β δ g₁ (WithTop.map.{u1, u2} α β f₁ ((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))) (WithTop.map.{u3, u4} γ δ g₂ (WithTop.map.{u1, u3} α γ f₂ ((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))))
-but is expected to have type
-  forall {α : Type.{u4}} {β : Type.{u2}} {γ : Type.{u1}} {δ : Type.{u3}} {f₁ : α -> β} {f₂ : α -> γ} {g₁ : β -> δ} {g₂ : γ -> δ}, (Eq.{max (succ u4) (succ u3)} (α -> δ) (Function.comp.{succ u4, succ u2, succ u3} α β δ g₁ f₁) (Function.comp.{succ u4, succ u1, succ u3} α γ δ g₂ f₂)) -> (forall (a : α), Eq.{succ u3} (WithTop.{u3} δ) (WithTop.map.{u2, u3} β δ g₁ (WithTop.map.{u4, u2} α β f₁ (WithTop.some.{u4} α a))) (WithTop.map.{u1, u3} γ δ g₂ (WithTop.map.{u4, u1} α γ f₂ (WithTop.some.{u4} α a))))
-Case conversion may be inaccurate. Consider using '#align with_top.map_comm WithTop.map_commₓ'. -/
 theorem map_comm {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂ : γ → δ} (h : g₁ ∘ f₁ = g₂ ∘ f₂)
     (a : α) : map g₁ (map f₁ a) = map g₂ (map f₂ a) :=
   Option.map_comm h _
 #align with_top.map_comm WithTop.map_comm
 
-/- warning: with_top.map_to_dual -> WithTop.map_toDual is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithBot.{u1} α), Eq.{succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithTop.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a)) (WithBot.map.{u1, u2} α (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} α β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) f) a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithBot.{u2} α), Eq.{succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.{u2} α) (fun (_x : WithBot.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u2} α) => WithTop.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.toDual.{u2} α) a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} (OrderDual.{u1} β)) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => OrderDual.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.toDual.{u1} (OrderDual.{u1} β))) f) a)
-Case conversion may be inaccurate. Consider using '#align with_top.map_to_dual WithTop.map_toDualₓ'. -/
 theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithBot α) :
     map f (WithBot.toDual a) = a.map (toDual ∘ f) :=
   rfl
 #align with_top.map_to_dual WithTop.map_toDual
 
-/- warning: with_top.map_of_dual -> WithTop.map_ofDual is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithBot.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithTop.{u2} β) (WithTop.map.{u1, u2} α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) β (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) f) a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithBot.{u2} (OrderDual.{u2} α)), Eq.{succ u1} (WithTop.{u1} β) (WithTop.map.{u2, u1} α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.{u2} (OrderDual.{u2} α)) (fun (_x : WithBot.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u2} (OrderDual.{u2} α)) => WithTop.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.ofDual.{u2} α) a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) f) a)
-Case conversion may be inaccurate. Consider using '#align with_top.map_of_dual WithTop.map_ofDualₓ'. -/
 theorem map_ofDual (f : α → β) (a : WithBot αᵒᵈ) : map f (WithBot.ofDual a) = a.map (ofDual ∘ f) :=
   rfl
 #align with_top.map_of_dual WithTop.map_ofDual
 
-/- warning: with_top.to_dual_map -> WithTop.toDual_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithTop.{u1} α), Eq.{succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} β) (WithBot.{u2} (OrderDual.{u2} β))) (fun (_x : Equiv.{succ u2, succ u2} (WithTop.{u2} β) (WithBot.{u2} (OrderDual.{u2} β))) => (WithTop.{u2} β) -> (WithBot.{u2} (OrderDual.{u2} β))) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithTop.{u2} β) (WithBot.{u2} (OrderDual.{u2} β))) (WithTop.toDual.{u2} β) (WithTop.map.{u1, u2} α β f a)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} (OrderDual.{u1} α) α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithTop.{u2} α), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} β) => WithBot.{u1} (OrderDual.{u1} β)) (WithTop.map.{u2, u1} α β f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} β) (WithBot.{u1} (OrderDual.{u1} β))) (WithTop.{u1} β) (fun (_x : WithTop.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} β) => WithBot.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} β) (WithBot.{u1} (OrderDual.{u1} β))) (WithTop.toDual.{u1} β) (WithTop.map.{u2, u1} α β f a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) β (OrderDual.{u1} β) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} β (OrderDual.{u1} β)) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => OrderDual.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β (OrderDual.{u1} β)) (OrderDual.toDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} (OrderDual.{u2} α) α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.{u2} α) (fun (_x : OrderDual.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u2} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.{u2} α) (fun (_x : WithTop.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u2} α) => WithBot.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.toDual.{u2} α) a))
-Case conversion may be inaccurate. Consider using '#align with_top.to_dual_map WithTop.toDual_mapₓ'. -/
 theorem toDual_map (f : α → β) (a : WithTop α) :
     WithTop.toDual (map f a) = WithBot.map (toDual ∘ f ∘ ofDual) a.toDual :=
   rfl
 #align with_top.to_dual_map WithTop.toDual_map
 
-/- warning: with_top.of_dual_map -> WithTop.ofDual_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithTop.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithBot.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithBot.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithBot.{u2} β)) => (WithTop.{u2} (OrderDual.{u2} β)) -> (WithBot.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithBot.{u2} β)) (WithTop.ofDual.{u2} β) (WithTop.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f a)) (WithBot.map.{u1, u2} α β (Function.comp.{succ u1, succ u2, succ u2} α (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} α (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithTop.{u2} (OrderDual.{u2} α)), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} β)) => WithBot.{u1} β) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithBot.{u1} β)) (WithTop.{u1} (OrderDual.{u1} β)) (fun (_x : WithTop.{u1} (OrderDual.{u1} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} β)) => WithBot.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithBot.{u1} β)) (WithTop.ofDual.{u1} β) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} α (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.{u2} (OrderDual.{u2} α)) (fun (_x : WithTop.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u2} (OrderDual.{u2} α)) => WithBot.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.ofDual.{u2} α) a))
-Case conversion may be inaccurate. Consider using '#align with_top.of_dual_map WithTop.ofDual_mapₓ'. -/
 theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithTop αᵒᵈ) :
     WithTop.ofDual (map f a) = WithBot.map (ofDual ∘ f ∘ toDual) a.ofDual :=
   rfl
@@ -1183,12 +913,6 @@ theorem toDual_le_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
 #align with_top.to_dual_le_iff WithTop.toDual_le_iff
 -/
 
-/- warning: with_top.le_to_dual_iff -> WithTop.le_toDual_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
-Case conversion may be inaccurate. Consider using '#align with_top.le_to_dual_iff WithTop.le_toDual_iffₓ'. -/
 theorem le_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     a ≤ WithTop.toDual b ↔ b ≤ WithBot.ofDual a :=
   Iff.rfl
@@ -1208,12 +932,6 @@ theorem ofDual_le_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
 #align with_top.of_dual_le_iff WithTop.ofDual_le_iff
 -/
 
-/- warning: with_top.le_of_dual_iff -> WithTop.le_ofDual_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
-Case conversion may be inaccurate. Consider using '#align with_top.le_of_dual_iff WithTop.le_ofDual_iffₓ'. -/
 theorem le_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     a ≤ WithTop.ofDual b ↔ b ≤ WithBot.toDual a :=
   Iff.rfl
@@ -1226,34 +944,16 @@ theorem ofDual_le_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a ≤ Wit
 #align with_top.of_dual_le_of_dual_iff WithTop.ofDual_le_ofDual_iff
 -/
 
-/- warning: with_top.coe_le_coe -> WithTop.coe_le_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α], Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{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) ((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} α))) b)) (LE.le.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α], Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) (WithTop.some.{u1} α a) (WithTop.some.{u1} α b)) (LE.le.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align with_top.coe_le_coe WithTop.coe_le_coeₓ'. -/
 @[simp, norm_cast]
 theorem coe_le_coe : (a : WithTop α) ≤ b ↔ a ≤ b := by
   simp only [← to_dual_le_to_dual_iff, to_dual_apply_coe, WithBot.coe_le_coe, to_dual_le_to_dual]
 #align with_top.coe_le_coe WithTop.coe_le_coe
 
-/- warning: with_top.some_le_some -> WithTop.some_le_some is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α], Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) (Option.some.{u1} α a) (Option.some.{u1} α b)) (LE.le.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α], Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) (Option.some.{u1} α a) (Option.some.{u1} α b)) (LE.le.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align with_top.some_le_some WithTop.some_le_someₓ'. -/
 @[simp]
 theorem some_le_some : @LE.le (WithTop α) _ (some a) (some b) ↔ a ≤ b :=
   coe_le_coe
 #align with_top.some_le_some WithTop.some_le_some
 
-/- warning: with_top.le_none -> WithTop.le_none is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithTop.{u1} α}, LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) a (Option.none.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithTop.{u1} α}, LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) a (Option.none.{u1} α)
-Case conversion may be inaccurate. Consider using '#align with_top.le_none WithTop.le_noneₓ'. -/
 @[simp]
 theorem le_none {a : WithTop α} : @LE.le (WithTop α) _ a none :=
   toDual_le_toDual_iff.mp WithBot.none_le
@@ -1270,42 +970,18 @@ instance [OrderBot α] : OrderBot (WithTop α)
 instance [OrderBot α] : BoundedOrder (WithTop α) :=
   { WithTop.orderTop, WithTop.orderBot with }
 
-/- warning: with_top.not_top_le_coe -> WithTop.not_top_le_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] (a : α), Not (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) ((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))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] (a : α), Not (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)) (WithTop.some.{u1} α a))
-Case conversion may be inaccurate. Consider using '#align with_top.not_top_le_coe WithTop.not_top_le_coeₓ'. -/
 theorem not_top_le_coe (a : α) : ¬(⊤ : WithTop α) ≤ ↑a :=
   WithBot.not_coe_le_bot (toDual a)
 #align with_top.not_top_le_coe WithTop.not_top_le_coe
 
-/- warning: with_top.le_coe -> WithTop.le_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α] {o : Option.{u1} α}, (Membership.Mem.{u1, u1} α (Option.{u1} α) (Option.hasMem.{u1} α) a o) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) o ((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} α))) b)) (LE.le.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : LE.{u1} α] {o : Option.{u1} α}, (Membership.mem.{u1, u1} α (Option.{u1} α) (Option.instMembershipOption.{u1} α) a o) -> (Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) o (WithTop.some.{u1} α b)) (LE.le.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align with_top.le_coe WithTop.le_coeₓ'. -/
 theorem le_coe : ∀ {o : Option α}, a ∈ o → (@LE.le (WithTop α) _ o b ↔ a ≤ b)
   | _, rfl => coe_le_coe
 #align with_top.le_coe WithTop.le_coe
 
-/- warning: with_top.le_coe_iff -> WithTop.le_coe_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {b : α} [_inst_1 : LE.{u1} α] {x : WithTop.{u1} α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) x ((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} α))) b)) (Exists.{succ u1} α (fun (a : α) => And (Eq.{succ u1} (WithTop.{u1} α) x ((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_1 a b)))
-but is expected to have type
-  forall {α : Type.{u1}} {b : α} [_inst_1 : LE.{u1} α] {x : WithTop.{u1} α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x (WithTop.some.{u1} α b)) (Exists.{succ u1} α (fun (a : α) => And (Eq.{succ u1} (WithTop.{u1} α) x (WithTop.some.{u1} α a)) (LE.le.{u1} α _inst_1 a b)))
-Case conversion may be inaccurate. Consider using '#align with_top.le_coe_iff WithTop.le_coe_iffₓ'. -/
 theorem le_coe_iff {x : WithTop α} : x ≤ b ↔ ∃ a : α, x = a ∧ a ≤ b := by
   simpa [← to_dual_le_to_dual_iff, WithBot.coe_le_iff]
 #align with_top.le_coe_iff WithTop.le_coe_iff
 
-/- warning: with_top.coe_le_iff -> WithTop.coe_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} [_inst_1 : LE.{u1} α] {x : WithTop.{u1} α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{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) x) (forall (b : α), (Eq.{succ u1} (WithTop.{u1} α) x ((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} α))) b)) -> (LE.le.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} [_inst_1 : LE.{u1} α] {x : WithTop.{u1} α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) (WithTop.some.{u1} α a) x) (forall (b : α), (Eq.{succ u1} (WithTop.{u1} α) x (WithTop.some.{u1} α b)) -> (LE.le.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align with_top.coe_le_iff WithTop.coe_le_iffₓ'. -/
 theorem coe_le_iff {x : WithTop α} : ↑a ≤ x ↔ ∀ b, x = ↑b → a ≤ b :=
   by
   simp only [← to_dual_le_to_dual_iff, to_dual_apply_coe, WithBot.le_coe_iff, OrderDual.forall,
@@ -1313,12 +989,6 @@ theorem coe_le_iff {x : WithTop α} : ↑a ≤ x ↔ ∀ b, x = ↑b → a ≤ b
   exact forall₂_congr fun _ _ => Iff.rfl
 #align with_top.coe_le_iff WithTop.coe_le_iff
 
-/- warning: is_min.with_top -> IsMin.withTop is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} [_inst_1 : LE.{u1} α], (IsMin.{u1} α _inst_1 a) -> (IsMin.{u1} (WithTop.{u1} α) (WithTop.hasLe.{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))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} [_inst_1 : LE.{u1} α], (IsMin.{u1} α _inst_1 a) -> (IsMin.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) (WithTop.some.{u1} α a))
-Case conversion may be inaccurate. Consider using '#align is_min.with_top IsMin.withTopₓ'. -/
 protected theorem IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) :=
   by
   -- defeq to is_max_to_dual_iff.mp (is_max.with_bot _), but that breaks API boundary
@@ -1336,67 +1006,31 @@ variable [LT α]
 instance (priority := 10) : LT (WithTop α) :=
   ⟨fun o₁ o₂ : Option α => ∃ b ∈ o₁, ∀ a ∈ o₂, b < a⟩
 
-/- warning: with_top.to_dual_lt_iff -> WithTop.toDual_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) b) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) a) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) b) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b) a)
-Case conversion may be inaccurate. Consider using '#align with_top.to_dual_lt_iff WithTop.toDual_lt_iffₓ'. -/
 theorem toDual_lt_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
     WithTop.toDual a < b ↔ WithBot.ofDual b < a :=
   Iff.rfl
 #align with_top.to_dual_lt_iff WithTop.toDual_lt_iff
 
-/- warning: with_top.lt_to_dual_iff -> WithTop.lt_toDual_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
-Case conversion may be inaccurate. Consider using '#align with_top.lt_to_dual_iff WithTop.lt_toDual_iffₓ'. -/
 theorem lt_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     a < WithTop.toDual b ↔ b < WithBot.ofDual a :=
   Iff.rfl
 #align with_top.lt_to_dual_iff WithTop.lt_toDual_iff
 
-/- warning: with_top.to_dual_lt_to_dual_iff -> WithTop.toDual_lt_toDual_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) a) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) b a)
-Case conversion may be inaccurate. Consider using '#align with_top.to_dual_lt_to_dual_iff WithTop.toDual_lt_toDual_iffₓ'. -/
 @[simp]
 theorem toDual_lt_toDual_iff {a b : WithTop α} : WithTop.toDual a < WithTop.toDual b ↔ b < a :=
   Iff.rfl
 #align with_top.to_dual_lt_to_dual_iff WithTop.toDual_lt_toDual_iff
 
-/- warning: with_top.of_dual_lt_iff -> WithTop.ofDual_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) b) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) a) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) b) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b) a)
-Case conversion may be inaccurate. Consider using '#align with_top.of_dual_lt_iff WithTop.ofDual_lt_iffₓ'. -/
 theorem ofDual_lt_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
     WithTop.ofDual a < b ↔ WithBot.toDual b < a :=
   Iff.rfl
 #align with_top.of_dual_lt_iff WithTop.ofDual_lt_iff
 
-/- warning: with_top.lt_of_dual_iff -> WithTop.lt_ofDual_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
-Case conversion may be inaccurate. Consider using '#align with_top.lt_of_dual_iff WithTop.lt_ofDual_iffₓ'. -/
 theorem lt_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     a < WithTop.ofDual b ↔ b < WithBot.toDual a :=
   Iff.rfl
 #align with_top.lt_of_dual_iff WithTop.lt_ofDual_iff
 
-/- warning: with_top.of_dual_lt_of_dual_iff -> WithTop.ofDual_lt_ofDual_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) a) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b a)
-Case conversion may be inaccurate. Consider using '#align with_top.of_dual_lt_of_dual_iff WithTop.ofDual_lt_ofDual_iffₓ'. -/
 @[simp]
 theorem ofDual_lt_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a < WithTop.ofDual b ↔ b < a :=
   Iff.rfl
@@ -1452,45 +1086,21 @@ theorem ofDual_apply_coe (a : αᵒᵈ) : WithBot.ofDual (a : WithBot αᵒᵈ)
 #align with_bot.of_dual_apply_coe WithBot.ofDual_apply_coe
 -/
 
-/- warning: with_bot.map_to_dual -> WithBot.map_toDual is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithTop.{u1} α), Eq.{succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a)) (WithTop.map.{u1, u2} α (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} α β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) f) a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithTop.{u2} α), Eq.{succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.{u2} α) (fun (_x : WithTop.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u2} α) => WithBot.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.toDual.{u2} α) a)) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} (OrderDual.{u1} β)) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => OrderDual.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.toDual.{u1} (OrderDual.{u1} β))) f) a)
-Case conversion may be inaccurate. Consider using '#align with_bot.map_to_dual WithBot.map_toDualₓ'. -/
 theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithTop α) :
     WithBot.map f (WithTop.toDual a) = a.map (toDual ∘ f) :=
   rfl
 #align with_bot.map_to_dual WithBot.map_toDual
 
-/- warning: with_bot.map_of_dual -> WithBot.map_ofDual is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithTop.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithBot.{u2} β) (WithBot.map.{u1, u2} α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a)) (WithTop.map.{u1, u2} (OrderDual.{u1} α) β (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) f) a)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithTop.{u2} (OrderDual.{u2} α)), Eq.{succ u1} (WithBot.{u1} β) (WithBot.map.{u2, u1} α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.{u2} (OrderDual.{u2} α)) (fun (_x : WithTop.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u2} (OrderDual.{u2} α)) => WithBot.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.ofDual.{u2} α) a)) (WithTop.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) f) a)
-Case conversion may be inaccurate. Consider using '#align with_bot.map_of_dual WithBot.map_ofDualₓ'. -/
 theorem map_ofDual (f : α → β) (a : WithTop αᵒᵈ) :
     WithBot.map f (WithTop.ofDual a) = a.map (ofDual ∘ f) :=
   rfl
 #align with_bot.map_of_dual WithBot.map_ofDual
 
-/- warning: with_bot.to_dual_map -> WithBot.toDual_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithBot.{u1} α), Eq.{succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} β) (WithTop.{u2} (OrderDual.{u2} β))) (fun (_x : Equiv.{succ u2, succ u2} (WithBot.{u2} β) (WithTop.{u2} (OrderDual.{u2} β))) => (WithBot.{u2} β) -> (WithTop.{u2} (OrderDual.{u2} β))) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithBot.{u2} β) (WithTop.{u2} (OrderDual.{u2} β))) (WithBot.toDual.{u2} β) (WithBot.map.{u1, u2} α β f a)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} (OrderDual.{u1} α) α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithBot.{u2} α), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} β) => WithTop.{u1} (OrderDual.{u1} β)) (WithBot.map.{u2, u1} α β f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} β) (WithTop.{u1} (OrderDual.{u1} β))) (WithBot.{u1} β) (fun (_x : WithBot.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} β) => WithTop.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} β) (WithTop.{u1} (OrderDual.{u1} β))) (WithBot.toDual.{u1} β) (WithBot.map.{u2, u1} α β f a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) β (OrderDual.{u1} β) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} β (OrderDual.{u1} β)) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => OrderDual.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β (OrderDual.{u1} β)) (OrderDual.toDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} (OrderDual.{u2} α) α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.{u2} α) (fun (_x : OrderDual.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u2} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.{u2} α) (fun (_x : WithBot.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u2} α) => WithTop.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.toDual.{u2} α) a))
-Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_map WithBot.toDual_mapₓ'. -/
 theorem toDual_map (f : α → β) (a : WithBot α) :
     WithBot.toDual (WithBot.map f a) = map (toDual ∘ f ∘ ofDual) a.toDual :=
   rfl
 #align with_bot.to_dual_map WithBot.toDual_map
 
-/- warning: with_bot.of_dual_map -> WithBot.ofDual_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithBot.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithTop.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithTop.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithTop.{u2} β)) => (WithBot.{u2} (OrderDual.{u2} β)) -> (WithTop.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithTop.{u2} β)) (WithBot.ofDual.{u2} β) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f a)) (WithBot.map.{u1, u2} α β (Function.comp.{succ u1, succ u2, succ u2} α (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} α (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithBot.{u2} (OrderDual.{u2} α)), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} β)) => WithTop.{u1} β) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithTop.{u1} β)) (WithBot.{u1} (OrderDual.{u1} β)) (fun (_x : WithBot.{u1} (OrderDual.{u1} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} β)) => WithTop.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithTop.{u1} β)) (WithBot.ofDual.{u1} β) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} α (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.{u2} (OrderDual.{u2} α)) (fun (_x : WithBot.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u2} (OrderDual.{u2} α)) => WithTop.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.ofDual.{u2} α) a))
-Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_map WithBot.ofDual_mapₓ'. -/
 theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithBot αᵒᵈ) :
     WithBot.ofDual (WithBot.map f a) = map (ofDual ∘ f ∘ toDual) a.ofDual :=
   rfl
@@ -1500,12 +1110,6 @@ section LE
 
 variable [LE α] {a b : α}
 
-/- warning: with_bot.to_dual_le_iff -> WithBot.toDual_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) b) (WithBot.le.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
-Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_le_iff WithBot.toDual_le_iffₓ'. -/
 theorem toDual_le_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     WithBot.toDual a ≤ b ↔ WithTop.ofDual b ≤ a :=
   Iff.rfl
@@ -1525,12 +1129,6 @@ theorem toDual_le_toDual_iff {a b : WithBot α} : WithBot.toDual a ≤ WithBot.t
 #align with_bot.to_dual_le_to_dual_iff WithBot.toDual_le_toDual_iff
 -/
 
-/- warning: with_bot.of_dual_le_iff -> WithBot.ofDual_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.le.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) b) (WithBot.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
-Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_le_iff WithBot.ofDual_le_iffₓ'. -/
 theorem ofDual_le_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     WithBot.ofDual a ≤ b ↔ WithTop.toDual b ≤ a :=
   Iff.rfl
@@ -1556,67 +1154,31 @@ section LT
 
 variable [LT α] {a b : α}
 
-/- warning: with_bot.to_dual_lt_iff -> WithBot.toDual_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) b) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
-Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_lt_iff WithBot.toDual_lt_iffₓ'. -/
 theorem toDual_lt_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     WithBot.toDual a < b ↔ WithTop.ofDual b < a :=
   Iff.rfl
 #align with_bot.to_dual_lt_iff WithBot.toDual_lt_iff
 
-/- warning: with_bot.lt_to_dual_iff -> WithBot.lt_toDual_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
-Case conversion may be inaccurate. Consider using '#align with_bot.lt_to_dual_iff WithBot.lt_toDual_iffₓ'. -/
 theorem lt_toDual_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
     a < WithBot.toDual b ↔ b < WithTop.ofDual a :=
   Iff.rfl
 #align with_bot.lt_to_dual_iff WithBot.lt_toDual_iff
 
-/- warning: with_bot.to_dual_lt_to_dual_iff -> WithBot.toDual_lt_toDual_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) b a)
-Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_lt_to_dual_iff WithBot.toDual_lt_toDual_iffₓ'. -/
 @[simp]
 theorem toDual_lt_toDual_iff {a b : WithBot α} : WithBot.toDual a < WithBot.toDual b ↔ b < a :=
   Iff.rfl
 #align with_bot.to_dual_lt_to_dual_iff WithBot.toDual_lt_toDual_iff
 
-/- warning: with_bot.of_dual_lt_iff -> WithBot.ofDual_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) b) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
-Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_lt_iff WithBot.ofDual_lt_iffₓ'. -/
 theorem ofDual_lt_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     WithBot.ofDual a < b ↔ WithTop.toDual b < a :=
   Iff.rfl
 #align with_bot.of_dual_lt_iff WithBot.ofDual_lt_iff
 
-/- warning: with_bot.lt_of_dual_iff -> WithBot.lt_ofDual_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
-Case conversion may be inaccurate. Consider using '#align with_bot.lt_of_dual_iff WithBot.lt_ofDual_iffₓ'. -/
 theorem lt_ofDual_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
     a < WithBot.ofDual b ↔ b < WithTop.toDual a :=
   Iff.rfl
 #align with_bot.lt_of_dual_iff WithBot.lt_ofDual_iff
 
-/- warning: with_bot.of_dual_lt_of_dual_iff -> WithBot.ofDual_lt_ofDual_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b a)
-Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_lt_of_dual_iff WithBot.ofDual_lt_ofDual_iffₓ'. -/
 @[simp]
 theorem ofDual_lt_ofDual_iff {a b : WithBot αᵒᵈ} : WithBot.ofDual a < WithBot.ofDual b ↔ b < a :=
   Iff.rfl
@@ -1634,55 +1196,25 @@ variable [LT α] {a b : α}
 
 open OrderDual
 
-/- warning: with_top.coe_lt_coe -> WithTop.coe_lt_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : α} {b : α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{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) ((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} α))) b)) (LT.lt.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : α} {b : α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) (WithTop.some.{u1} α a) (WithTop.some.{u1} α b)) (LT.lt.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align with_top.coe_lt_coe WithTop.coe_lt_coeₓ'. -/
 @[simp, norm_cast]
 theorem coe_lt_coe : (a : WithTop α) < b ↔ a < b := by
   simp only [← to_dual_lt_to_dual_iff, to_dual_apply_coe, WithBot.coe_lt_coe, to_dual_lt_to_dual]
 #align with_top.coe_lt_coe WithTop.coe_lt_coe
 
-/- warning: with_top.some_lt_some -> WithTop.some_lt_some is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : α} {b : α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (Option.some.{u1} α a) (Option.some.{u1} α b)) (LT.lt.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : α} {b : α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) (Option.some.{u1} α a) (Option.some.{u1} α b)) (LT.lt.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align with_top.some_lt_some WithTop.some_lt_someₓ'. -/
 @[simp]
 theorem some_lt_some : @LT.lt (WithTop α) _ (some a) (some b) ↔ a < b :=
   coe_lt_coe
 #align with_top.some_lt_some WithTop.some_lt_some
 
-/- warning: with_top.coe_lt_top -> WithTop.coe_lt_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : α), LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{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) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : α), LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) (WithTop.some.{u1} α a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))
-Case conversion may be inaccurate. Consider using '#align with_top.coe_lt_top WithTop.coe_lt_topₓ'. -/
 theorem coe_lt_top (a : α) : (a : WithTop α) < ⊤ := by
   simpa [← to_dual_lt_to_dual_iff] using WithBot.bot_lt_coe _
 #align with_top.coe_lt_top WithTop.coe_lt_top
 
-/- warning: with_top.some_lt_none -> WithTop.some_lt_none is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : α), LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (Option.some.{u1} α a) (Option.none.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : α), LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) (Option.some.{u1} α a) (Option.none.{u1} α)
-Case conversion may be inaccurate. Consider using '#align with_top.some_lt_none WithTop.some_lt_noneₓ'. -/
 @[simp]
 theorem some_lt_none (a : α) : @LT.lt (WithTop α) _ (some a) none :=
   coe_lt_top a
 #align with_top.some_lt_none WithTop.some_lt_none
 
-/- warning: with_top.not_none_lt -> WithTop.not_none_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : WithTop.{u1} α), Not (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (Option.none.{u1} α) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] (a : WithTop.{u1} α), Not (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) (Option.none.{u1} α) a)
-Case conversion may be inaccurate. Consider using '#align with_top.not_none_lt WithTop.not_none_ltₓ'. -/
 @[simp]
 theorem not_none_lt (a : WithTop α) : ¬@LT.lt (WithTop α) _ none a :=
   by
@@ -1690,24 +1222,12 @@ theorem not_none_lt (a : WithTop α) : ¬@LT.lt (WithTop α) _ none a :=
   exact WithBot.not_lt_none _
 #align with_top.not_none_lt WithTop.not_none_lt
 
-/- warning: with_top.lt_iff_exists_coe -> WithTop.lt_iff_exists_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) a b) (Exists.{succ u1} α (fun (p : α) => And (Eq.{succ u1} (WithTop.{u1} α) a ((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} α))) p)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{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} α))) p) b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) a b) (Exists.{succ u1} α (fun (p : α) => And (Eq.{succ u1} (WithTop.{u1} α) a (WithTop.some.{u1} α p)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) (WithTop.some.{u1} α p) b)))
-Case conversion may be inaccurate. Consider using '#align with_top.lt_iff_exists_coe WithTop.lt_iff_exists_coeₓ'. -/
 theorem lt_iff_exists_coe {a b : WithTop α} : a < b ↔ ∃ p : α, a = p ∧ ↑p < b :=
   by
   rw [← to_dual_lt_to_dual_iff, WithBot.lt_iff_exists_coe, OrderDual.exists]
   exact exists_congr fun _ => and_congr_left' Iff.rfl
 #align with_top.lt_iff_exists_coe WithTop.lt_iff_exists_coe
 
-/- warning: with_top.coe_lt_iff -> WithTop.coe_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : α} {x : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{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) x) (forall (b : α), (Eq.{succ u1} (WithTop.{u1} α) x ((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} α))) b)) -> (LT.lt.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : α} {x : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) (WithTop.some.{u1} α a) x) (forall (b : WithTop.{u1} α), (Eq.{succ u1} (WithTop.{u1} α) x b) -> (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) (WithTop.some.{u1} α a) b))
-Case conversion may be inaccurate. Consider using '#align with_top.coe_lt_iff WithTop.coe_lt_iffₓ'. -/
 theorem coe_lt_iff {x : WithTop α} : ↑a < x ↔ ∀ b, x = ↑b → a < b :=
   by
   simp only [← to_dual_lt_to_dual_iff, WithBot.lt_coe_iff, to_dual_apply_coe, OrderDual.forall,
@@ -1715,12 +1235,6 @@ theorem coe_lt_iff {x : WithTop α} : ↑a < x ↔ ∀ b, x = ↑b → a < b :=
   exact forall₂_congr fun _ _ => Iff.rfl
 #align with_top.coe_lt_iff WithTop.coe_lt_iff
 
-/- warning: with_top.lt_top_iff_ne_top -> WithTop.lt_top_iff_ne_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {x : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) x (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) x (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {x : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) x (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align with_top.lt_top_iff_ne_top WithTop.lt_top_iff_ne_topₓ'. -/
 /-- A version of `lt_top_iff_ne_top` for `with_top` that only requires `has_lt α`, not
 `partial_order α`. -/
 protected theorem lt_top_iff_ne_top {x : WithTop α} : x < ⊤ ↔ x ≠ ⊤ :=
@@ -1752,12 +1266,6 @@ theorem coe_mono [Preorder α] : Monotone (coe : α → WithTop α) := fun a b =
 #align with_top.coe_mono WithTop.coe_mono
 -/
 
-/- warning: with_top.monotone_iff -> WithTop.monotone_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithTop.{u1} α) -> β}, Iff (Monotone.{u1, u2} (WithTop.{u1} α) β (WithTop.preorder.{u1} α _inst_1) _inst_2 f) (And (Monotone.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithTop.{u1} α) β f ((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} α)))))) (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f ((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} α))) x)) (f (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : (WithTop.{u2} α) -> β}, Iff (Monotone.{u2, u1} (WithTop.{u2} α) β (WithTop.preorder.{u2} α _inst_1) _inst_2 f) (And (Monotone.{u2, u1} α β _inst_1 _inst_2 (fun (a : α) => f (WithTop.some.{u2} α a))) (forall (x : α), LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f (WithTop.some.{u2} α x)) (f (Top.top.{u2} (WithTop.{u2} α) (WithTop.top.{u2} α)))))
-Case conversion may be inaccurate. Consider using '#align with_top.monotone_iff WithTop.monotone_iffₓ'. -/
 theorem monotone_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
     Monotone f ↔ Monotone (f ∘ coe : α → β) ∧ ∀ x : α, f x ≤ f ⊤ :=
   ⟨fun h => ⟨h.comp WithTop.coe_mono, fun x => h le_top⟩, fun h =>
@@ -1766,33 +1274,15 @@ theorem monotone_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
         WithTop.forall.2 ⟨fun _ => h.2 x, fun y hle => h.1 (coe_le_coe.1 hle)⟩⟩⟩
 #align with_top.monotone_iff WithTop.monotone_iff
 
-/- warning: with_top.monotone_map_iff -> WithTop.monotone_map_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (Monotone.{u1, u2} (WithTop.{u1} α) (WithTop.{u2} β) (WithTop.preorder.{u1} α _inst_1) (WithTop.preorder.{u2} β _inst_2) (WithTop.map.{u1, u2} α β f)) (Monotone.{u1, u2} α β _inst_1 _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, Iff (Monotone.{u2, u1} (WithTop.{u2} α) (WithTop.{u1} β) (WithTop.preorder.{u2} α _inst_1) (WithTop.preorder.{u1} β _inst_2) (WithTop.map.{u2, u1} α β f)) (Monotone.{u2, u1} α β _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align with_top.monotone_map_iff WithTop.monotone_map_iffₓ'. -/
 @[simp]
 theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
     Monotone (WithTop.map f) ↔ Monotone f :=
   monotone_iff.trans <| by simp [Monotone]
 #align with_top.monotone_map_iff WithTop.monotone_map_iff
 
-/- warning: monotone.with_top_map -> Monotone.withTop_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (Monotone.{u1, u2} (WithTop.{u1} α) (WithTop.{u2} β) (WithTop.preorder.{u1} α _inst_1) (WithTop.preorder.{u2} β _inst_2) (WithTop.map.{u1, u2} α β f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (Monotone.{u2, u1} α β _inst_1 _inst_2 f) -> (Monotone.{u2, u1} (WithTop.{u2} α) (WithTop.{u1} β) (WithTop.preorder.{u2} α _inst_1) (WithTop.preorder.{u1} β _inst_2) (WithTop.map.{u2, u1} α β f))
-Case conversion may be inaccurate. Consider using '#align monotone.with_top_map Monotone.withTop_mapₓ'. -/
 alias monotone_map_iff ↔ _ _root_.monotone.with_top_map
 #align monotone.with_top_map Monotone.withTop_map
 
-/- warning: with_top.strict_mono_iff -> WithTop.strictMono_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithTop.{u1} α) -> β}, Iff (StrictMono.{u1, u2} (WithTop.{u1} α) β (WithTop.preorder.{u1} α _inst_1) _inst_2 f) (And (StrictMono.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithTop.{u1} α) β f ((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} α)))))) (forall (x : α), LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f ((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} α))) x)) (f (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : (WithTop.{u2} α) -> β}, Iff (StrictMono.{u2, u1} (WithTop.{u2} α) β (WithTop.preorder.{u2} α _inst_1) _inst_2 f) (And (StrictMono.{u2, u1} α β _inst_1 _inst_2 (fun (a : α) => f (WithTop.some.{u2} α a))) (forall (x : α), LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (f (WithTop.some.{u2} α x)) (f (Top.top.{u2} (WithTop.{u2} α) (WithTop.top.{u2} α)))))
-Case conversion may be inaccurate. Consider using '#align with_top.strict_mono_iff WithTop.strictMono_iffₓ'. -/
 theorem strictMono_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
     StrictMono f ↔ StrictMono (f ∘ coe : α → β) ∧ ∀ x : α, f x < f ⊤ :=
   ⟨fun h => ⟨h.comp WithTop.coe_strictMono, fun x => h (coe_lt_top _)⟩, fun h =>
@@ -1801,33 +1291,15 @@ theorem strictMono_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
         WithTop.forall.2 ⟨fun _ => h.2 x, fun y hle => h.1 (coe_lt_coe.1 hle)⟩⟩⟩
 #align with_top.strict_mono_iff WithTop.strictMono_iff
 
-/- warning: with_top.strict_mono_map_iff -> WithTop.strictMono_map_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (StrictMono.{u1, u2} (WithTop.{u1} α) (WithTop.{u2} β) (WithTop.preorder.{u1} α _inst_1) (WithTop.preorder.{u2} β _inst_2) (WithTop.map.{u1, u2} α β f)) (StrictMono.{u1, u2} α β _inst_1 _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, Iff (StrictMono.{u2, u1} (WithTop.{u2} α) (WithTop.{u1} β) (WithTop.preorder.{u2} α _inst_1) (WithTop.preorder.{u1} β _inst_2) (WithTop.map.{u2, u1} α β f)) (StrictMono.{u2, u1} α β _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align with_top.strict_mono_map_iff WithTop.strictMono_map_iffₓ'. -/
 @[simp]
 theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
     StrictMono (WithTop.map f) ↔ StrictMono f :=
   strictMono_iff.trans <| by simp [StrictMono, coe_lt_top]
 #align with_top.strict_mono_map_iff WithTop.strictMono_map_iff
 
-/- warning: strict_mono.with_top_map -> StrictMono.withTop_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictMono.{u1, u2} (WithTop.{u1} α) (WithTop.{u2} β) (WithTop.preorder.{u1} α _inst_1) (WithTop.preorder.{u2} β _inst_2) (WithTop.map.{u1, u2} α β f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (StrictMono.{u2, u1} α β _inst_1 _inst_2 f) -> (StrictMono.{u2, u1} (WithTop.{u2} α) (WithTop.{u1} β) (WithTop.preorder.{u2} α _inst_1) (WithTop.preorder.{u1} β _inst_2) (WithTop.map.{u2, u1} α β f))
-Case conversion may be inaccurate. Consider using '#align strict_mono.with_top_map StrictMono.withTop_mapₓ'. -/
 alias strict_mono_map_iff ↔ _ _root_.strict_mono.with_top_map
 #align strict_mono.with_top_map StrictMono.withTop_map
 
-/- warning: with_top.map_le_iff -> WithTop.map_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β) (a : WithTop.{u1} α) (b : WithTop.{u1} α), (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)) -> (Iff (LE.le.{u2} (WithTop.{u2} β) (Preorder.toHasLe.{u2} (WithTop.{u2} β) (WithTop.preorder.{u2} β _inst_2)) (WithTop.map.{u1, u2} α β f a) (WithTop.map.{u1, u2} α β f b)) (LE.le.{u1} (WithTop.{u1} α) (Preorder.toHasLe.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] (f : α -> β) (a : WithTop.{u2} α) (b : WithTop.{u2} α), (forall {a : α} {b : α}, Iff (LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f a) (f b)) (LE.le.{u2} α (Preorder.toLE.{u2} α _inst_1) a b)) -> (Iff (LE.le.{u1} (WithTop.{u1} β) (Preorder.toLE.{u1} (WithTop.{u1} β) (WithTop.preorder.{u1} β _inst_2)) (WithTop.map.{u2, u1} α β f a) (WithTop.map.{u2, u1} α β f b)) (LE.le.{u2} (WithTop.{u2} α) (Preorder.toLE.{u2} (WithTop.{u2} α) (WithTop.preorder.{u2} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align with_top.map_le_iff WithTop.map_le_iffₓ'. -/
 theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (a b : WithTop α)
     (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) : a.map f ≤ b.map f ↔ a ≤ b :=
   by
@@ -1850,12 +1322,6 @@ instance [SemilatticeInf α] : SemilatticeInf (WithTop α) :=
         simp at h₂
         exact ⟨d, rfl, le_inf h₁' h₂⟩ }
 
-/- warning: with_top.coe_inf -> WithTop.coe_inf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithTop.{u1} α) ((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} α))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b)) (Inf.inf.{u1} (WithTop.{u1} α) (SemilatticeInf.toHasInf.{u1} (WithTop.{u1} α) (WithTop.semilatticeInf.{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) ((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} α))) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b)) (Inf.inf.{u1} (WithTop.{u1} α) (SemilatticeInf.toInf.{u1} (WithTop.{u1} α) (WithTop.semilatticeInf.{u1} α _inst_1)) (WithTop.some.{u1} α a) (WithTop.some.{u1} α b))
-Case conversion may be inaccurate. Consider using '#align with_top.coe_inf WithTop.coe_infₓ'. -/
 theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithTop α) = a ⊓ b :=
   rfl
 #align with_top.coe_inf WithTop.coe_inf
@@ -1877,12 +1343,6 @@ instance [SemilatticeSup α] : SemilatticeSup (WithTop α) :=
       rcases h₂ a rfl with ⟨c, ⟨⟩, ac⟩
       exact ⟨_, rfl, sup_le ab ac⟩ }
 
-/- warning: with_top.coe_sup -> WithTop.coe_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithTop.{u1} α) ((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} α))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b)) (Sup.sup.{u1} (WithTop.{u1} α) (SemilatticeSup.toHasSup.{u1} (WithTop.{u1} α) (WithTop.semilatticeSup.{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) ((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} α))) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b)) (Sup.sup.{u1} (WithTop.{u1} α) (SemilatticeSup.toSup.{u1} (WithTop.{u1} α) (WithTop.semilatticeSup.{u1} α _inst_1)) (WithTop.some.{u1} α a) (WithTop.some.{u1} α b))
-Case conversion may be inaccurate. Consider using '#align with_top.coe_sup WithTop.coe_supₓ'. -/
 theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithTop α) = a ⊔ b :=
   rfl
 #align with_top.coe_sup WithTop.coe_sup
@@ -1900,32 +1360,14 @@ instance [DistribLattice α] : DistribLattice (WithTop α) :=
       | (a₁ : α), (a₂ : α), ⊤ => le_rfl
       | (a₁ : α), (a₂ : α), (a₃ : α) => coe_le_coe.mpr le_sup_inf }
 
-/- warning: with_top.decidable_le -> WithTop.decidableLE is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10423 : α) (x._@.Mathlib.Order.WithBot._hyg.10425 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10423 x._@.Mathlib.Order.WithBot._hyg.10425)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10443 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10445 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10443 x._@.Mathlib.Order.WithBot._hyg.10445)
-Case conversion may be inaccurate. Consider using '#align with_top.decidable_le WithTop.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithTop α) (· ≤ ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLE _ _) toDual_le_toDual_iff
 #align with_top.decidable_le WithTop.decidableLE
 
-/- warning: with_top.decidable_lt -> WithTop.decidableLT is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10478 : α) (x._@.Mathlib.Order.WithBot._hyg.10480 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10478 x._@.Mathlib.Order.WithBot._hyg.10480)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10498 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10500 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10498 x._@.Mathlib.Order.WithBot._hyg.10500)
-Case conversion may be inaccurate. Consider using '#align with_top.decidable_lt WithTop.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithTop α) (· < ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLT _ _) toDual_lt_toDual_iff
 #align with_top.decidable_lt WithTop.decidableLT
 
-/- warning: with_top.is_total_le -> WithTop.isTotal_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10533 : α) (x._@.Mathlib.Order.WithBot._hyg.10535 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10533 x._@.Mathlib.Order.WithBot._hyg.10535)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10553 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10555 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10553 x._@.Mathlib.Order.WithBot._hyg.10555)
-Case conversion may be inaccurate. Consider using '#align with_top.is_total_le WithTop.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) :=
   ⟨fun _ _ => by simp_rw [← to_dual_le_to_dual_iff]; exact total_of _ _ _⟩
 #align with_top.is_total_le WithTop.isTotal_le
@@ -1933,34 +1375,16 @@ instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (·
 instance [LinearOrder α] : LinearOrder (WithTop α) :=
   Lattice.toLinearOrder _
 
-/- warning: with_top.coe_min -> WithTop.coe_min is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (x : α) (y : α), Eq.{succ u1} (WithTop.{u1} α) ((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} α))) (LinearOrder.min.{u1} α _inst_1 x y)) (LinearOrder.min.{u1} (WithTop.{u1} α) (WithTop.linearOrder.{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} α))) x) ((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} α))) y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (x : α) (y : α), Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) x y)) (Min.min.{u1} (WithTop.{u1} α) (LinearOrder.toMin.{u1} (WithTop.{u1} α) (WithTop.linearOrder.{u1} α _inst_1)) (WithTop.some.{u1} α x) (WithTop.some.{u1} α y))
-Case conversion may be inaccurate. Consider using '#align with_top.coe_min WithTop.coe_minₓ'. -/
 @[simp, norm_cast]
 theorem coe_min [LinearOrder α] (x y : α) : (↑(min x y) : WithTop α) = min x y :=
   rfl
 #align with_top.coe_min WithTop.coe_min
 
-/- warning: with_top.coe_max -> WithTop.coe_max is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (x : α) (y : α), Eq.{succ u1} (WithTop.{u1} α) ((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} α))) (LinearOrder.max.{u1} α _inst_1 x y)) (LinearOrder.max.{u1} (WithTop.{u1} α) (WithTop.linearOrder.{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} α))) x) ((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} α))) y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (x : α) (y : α), Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) x y)) (Max.max.{u1} (WithTop.{u1} α) (LinearOrder.toMax.{u1} (WithTop.{u1} α) (WithTop.linearOrder.{u1} α _inst_1)) (WithTop.some.{u1} α x) (WithTop.some.{u1} α y))
-Case conversion may be inaccurate. Consider using '#align with_top.coe_max WithTop.coe_maxₓ'. -/
 @[simp, norm_cast]
 theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max x y :=
   rfl
 #align with_top.coe_max WithTop.coe_max
 
-/- warning: with_top.well_founded_lt -> WithTop.wellFounded_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10680 : α) (x._@.Mathlib.Order.WithBot._hyg.10682 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10680 x._@.Mathlib.Order.WithBot._hyg.10682)) -> (WellFounded.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10700 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10702 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.10700 x._@.Mathlib.Order.WithBot._hyg.10702))
-Case conversion may be inaccurate. Consider using '#align with_top.well_founded_lt WithTop.wellFounded_ltₓ'. -/
 theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithTop α) (· < ·) :=
   have acc_some : ∀ a : α, Acc ((· < ·) : WithTop α → WithTop α → Prop) (some a) := fun a =>
@@ -1981,12 +1405,6 @@ theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
 
 open OrderDual
 
-/- warning: with_top.well_founded_gt -> WithTop.wellFounded_gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithTop.{u1} α) (GT.gt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10931 : α) (x._@.Mathlib.Order.WithBot._hyg.10933 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10931 x._@.Mathlib.Order.WithBot._hyg.10933)) -> (WellFounded.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10951 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10953 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.10951 x._@.Mathlib.Order.WithBot._hyg.10953))
-Case conversion may be inaccurate. Consider using '#align with_top.well_founded_gt WithTop.wellFounded_gtₓ'. -/
 theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithTop α) (· > ·) :=
   ⟨fun a =>
@@ -1999,12 +1417,6 @@ theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     exact ⟨_, fun a' h => IH a'.toDual (to_dual_lt_to_dual.mpr h) _ rfl⟩⟩
 #align with_top.well_founded_gt WithTop.wellFounded_gt
 
-/- warning: with_bot.well_founded_gt -> WithBot.wellFounded_gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithBot.{u1} α) (GT.gt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11090 : α) (x._@.Mathlib.Order.WithBot._hyg.11092 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11090 x._@.Mathlib.Order.WithBot._hyg.11092)) -> (WellFounded.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11110 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11112 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11110 x._@.Mathlib.Order.WithBot._hyg.11112))
-Case conversion may be inaccurate. Consider using '#align with_bot.well_founded_gt WithBot.wellFounded_gtₓ'. -/
 theorem WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithBot α) (· > ·) :=
   ⟨fun a =>
@@ -2017,12 +1429,6 @@ theorem WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     exact ⟨_, fun a' h => IH a'.toDual (to_dual_lt_to_dual.mpr h) _ rfl⟩⟩
 #align with_bot.well_founded_gt WithBot.wellFounded_gt
 
-/- warning: with_top.trichotomous.lt -> WithTop.trichotomous.lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11253 : α) (x._@.Mathlib.Order.WithBot._hyg.11255 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11253 x._@.Mathlib.Order.WithBot._hyg.11255)], IsTrichotomous.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11273 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11275 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11273 x._@.Mathlib.Order.WithBot._hyg.11275)
-Case conversion may be inaccurate. Consider using '#align with_top.trichotomous.lt WithTop.trichotomous.ltₓ'. -/
 instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithTop α) (· < ·) :=
   ⟨by
@@ -2031,22 +1437,10 @@ instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     simpa [Option.some_inj] using @trichotomous _ (· < ·) _ a b⟩
 #align with_top.trichotomous.lt WithTop.trichotomous.lt
 
-/- warning: with_top.is_well_order.lt -> WithTop.IsWellOrder.lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11346 : α) (x._@.Mathlib.Order.WithBot._hyg.11348 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11346 x._@.Mathlib.Order.WithBot._hyg.11348)], IsWellOrder.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11366 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11368 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11366 x._@.Mathlib.Order.WithBot._hyg.11368)
-Case conversion may be inaccurate. Consider using '#align with_top.is_well_order.lt WithTop.IsWellOrder.ltₓ'. -/
 instance IsWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] : IsWellOrder (WithTop α) (· < ·)
     where wf := wellFounded_lt h.wf
 #align with_top.is_well_order.lt WithTop.IsWellOrder.lt
 
-/- warning: with_top.trichotomous.gt -> WithTop.trichotomous.gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithTop.{u1} α) (GT.gt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11403 : α) (x._@.Mathlib.Order.WithBot._hyg.11405 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11403 x._@.Mathlib.Order.WithBot._hyg.11405)], IsTrichotomous.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11423 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11425 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11423 x._@.Mathlib.Order.WithBot._hyg.11425)
-Case conversion may be inaccurate. Consider using '#align with_top.trichotomous.gt WithTop.trichotomous.gtₓ'. -/
 instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     IsTrichotomous (WithTop α) (· > ·) :=
   ⟨by
@@ -2055,55 +1449,25 @@ instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     simpa [Option.some_inj] using @trichotomous _ (· > ·) _ a b⟩
 #align with_top.trichotomous.gt WithTop.trichotomous.gt
 
-/- warning: with_top.is_well_order.gt -> WithTop.IsWellOrder.gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithTop.{u1} α) (GT.gt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11496 : α) (x._@.Mathlib.Order.WithBot._hyg.11498 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11496 x._@.Mathlib.Order.WithBot._hyg.11498)], IsWellOrder.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11516 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11518 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11516 x._@.Mathlib.Order.WithBot._hyg.11518)
-Case conversion may be inaccurate. Consider using '#align with_top.is_well_order.gt WithTop.IsWellOrder.gtₓ'. -/
 instance IsWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] : IsWellOrder (WithTop α) (· > ·)
     where wf := wellFounded_gt h.wf
 #align with_top.is_well_order.gt WithTop.IsWellOrder.gt
 
-/- warning: with_bot.trichotomous.lt -> WithBot.trichotomous.lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11549 : α) (x._@.Mathlib.Order.WithBot._hyg.11551 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11549 x._@.Mathlib.Order.WithBot._hyg.11551)], IsTrichotomous.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11569 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11571 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11569 x._@.Mathlib.Order.WithBot._hyg.11571)
-Case conversion may be inaccurate. Consider using '#align with_bot.trichotomous.lt WithBot.trichotomous.ltₓ'. -/
 instance WithBot.trichotomous.lt [Preorder α] [h : IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithBot α) (· < ·) :=
   @WithTop.trichotomous.gt αᵒᵈ _ h
 #align with_bot.trichotomous.lt WithBot.trichotomous.lt
 
-/- warning: with_bot.is_well_order.lt -> WithBot.isWellOrder.lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11601 : α) (x._@.Mathlib.Order.WithBot._hyg.11603 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11601 x._@.Mathlib.Order.WithBot._hyg.11603)], IsWellOrder.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11621 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11623 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11621 x._@.Mathlib.Order.WithBot._hyg.11623)
-Case conversion may be inaccurate. Consider using '#align with_bot.is_well_order.lt WithBot.isWellOrder.ltₓ'. -/
 instance WithBot.isWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] :
     IsWellOrder (WithBot α) (· < ·) :=
   @WithTop.IsWellOrder.gt αᵒᵈ _ h
 #align with_bot.is_well_order.lt WithBot.isWellOrder.lt
 
-/- warning: with_bot.trichotomous.gt -> WithBot.trichotomous.gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithBot.{u1} α) (GT.gt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11653 : α) (x._@.Mathlib.Order.WithBot._hyg.11655 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11653 x._@.Mathlib.Order.WithBot._hyg.11655)], IsTrichotomous.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11673 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11675 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11673 x._@.Mathlib.Order.WithBot._hyg.11675)
-Case conversion may be inaccurate. Consider using '#align with_bot.trichotomous.gt WithBot.trichotomous.gtₓ'. -/
 instance WithBot.trichotomous.gt [Preorder α] [h : IsTrichotomous α (· > ·)] :
     IsTrichotomous (WithBot α) (· > ·) :=
   @WithTop.trichotomous.lt αᵒᵈ _ h
 #align with_bot.trichotomous.gt WithBot.trichotomous.gt
 
-/- warning: with_bot.is_well_order.gt -> WithBot.isWellOrder.gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithBot.{u1} α) (GT.gt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11705 : α) (x._@.Mathlib.Order.WithBot._hyg.11707 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11705 x._@.Mathlib.Order.WithBot._hyg.11707)], IsWellOrder.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11725 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11727 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11725 x._@.Mathlib.Order.WithBot._hyg.11727)
-Case conversion may be inaccurate. Consider using '#align with_bot.is_well_order.gt WithBot.isWellOrder.gtₓ'. -/
 instance WithBot.isWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] :
     IsWellOrder (WithBot α) (· > ·) :=
   @WithTop.IsWellOrder.lt αᵒᵈ _ h
@@ -2112,12 +1476,6 @@ instance WithBot.isWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] :
 instance [LT α] [DenselyOrdered α] [NoMaxOrder α] : DenselyOrdered (WithTop α) :=
   OrderDual.denselyOrdered (WithBot αᵒᵈ)
 
-/- warning: with_top.lt_iff_exists_coe_btwn -> WithTop.lt_iff_exists_coe_btwn is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DenselyOrdered.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (x : α) => And (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a ((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} α))) x)) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{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} α))) x) b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DenselyOrdered.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (x : α) => And (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a (WithTop.some.{u1} α x)) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) (WithTop.some.{u1} α x) b)))
-Case conversion may be inaccurate. Consider using '#align with_top.lt_iff_exists_coe_btwn WithTop.lt_iff_exists_coe_btwnₓ'. -/
 theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMaxOrder α] {a b : WithTop α} :
     a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b :=
   ⟨fun h =>

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -249,11 +249,8 @@ def unbot : ∀ x : WithBot α, x ≠ ⊥ → α
 
 #print WithBot.coe_unbot /-
 @[simp]
-theorem coe_unbot (x : WithBot α) (h : x ≠ ⊥) : (x.unbot h : WithBot α) = x :=
-  by
-  cases x
-  simpa using h
-  rfl
+theorem coe_unbot (x : WithBot α) (h : x ≠ ⊥) : (x.unbot h : WithBot α) = x := by cases x;
+  simpa using h; rfl
 #align with_bot.coe_unbot WithBot.coe_unbot
 -/
 
@@ -476,8 +473,7 @@ instance [Preorder α] : Preorder (WithBot α)
     where
   le := (· ≤ ·)
   lt := (· < ·)
-  lt_iff_le_not_le := by
-    intros
+  lt_iff_le_not_le := by intros ;
     cases a <;> cases b <;> simp [lt_iff_le_not_le] <;> simp [(· < ·), (· ≤ ·)]
   le_refl o a ha := ⟨a, ha, le_rfl⟩
   le_trans o₁ o₂ o₃ h₁ h₂ a ha :=
@@ -489,8 +485,7 @@ instance [PartialOrder α] : PartialOrder (WithBot α) :=
   { WithBot.preorder with
     le_antisymm := fun o₁ o₂ h₁ h₂ => by
       cases' o₁ with a
-      · cases' o₂ with b
-        · rfl
+      · cases' o₂ with b; · rfl
         rcases h₂ b rfl with ⟨_, ⟨⟩, _⟩
       · rcases h₁ a rfl with ⟨b, ⟨⟩, h₁'⟩
         rcases h₂ b rfl with ⟨_, ⟨⟩, h₂'⟩
@@ -1740,14 +1735,11 @@ instance [Preorder α] : Preorder (WithTop α)
   lt := (· < ·)
   lt_iff_le_not_le := by simp [← to_dual_lt_to_dual_iff, lt_iff_le_not_le]
   le_refl _ := toDual_le_toDual_iff.mp le_rfl
-  le_trans _ _ _ := by
-    simp_rw [← to_dual_le_to_dual_iff]
-    exact Function.swap le_trans
+  le_trans _ _ _ := by simp_rw [← to_dual_le_to_dual_iff]; exact Function.swap le_trans
 
 instance [PartialOrder α] : PartialOrder (WithTop α) :=
   { WithTop.preorder with
-    le_antisymm := fun _ _ => by
-      simp_rw [← to_dual_le_to_dual_iff]
+    le_antisymm := fun _ _ => by simp_rw [← to_dual_le_to_dual_iff];
       exact Function.swap le_antisymm }
 
 #print WithTop.coe_strictMono /-
@@ -1935,9 +1927,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10533 : α) (x._@.Mathlib.Order.WithBot._hyg.10535 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10533 x._@.Mathlib.Order.WithBot._hyg.10535)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10553 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10555 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10553 x._@.Mathlib.Order.WithBot._hyg.10555)
 Case conversion may be inaccurate. Consider using '#align with_top.is_total_le WithTop.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) :=
-  ⟨fun _ _ => by
-    simp_rw [← to_dual_le_to_dual_iff]
-    exact total_of _ _ _⟩
+  ⟨fun _ _ => by simp_rw [← to_dual_le_to_dual_iff]; exact total_of _ _ _⟩
 #align with_top.is_total_le WithTop.isTotal_le
 
 instance [LinearOrder α] : LinearOrder (WithTop α) :=

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -695,7 +695,7 @@ instance [DistribLattice α] : DistribLattice (WithBot α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4202 : α) (x._@.Mathlib.Order.WithBot._hyg.4204 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4202 x._@.Mathlib.Order.WithBot._hyg.4204)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4222 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4224 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4222 x._@.Mathlib.Order.WithBot._hyg.4224)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4222 : α) (x._@.Mathlib.Order.WithBot._hyg.4224 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4222 x._@.Mathlib.Order.WithBot._hyg.4224)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4242 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4244 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4242 x._@.Mathlib.Order.WithBot._hyg.4244)
 Case conversion may be inaccurate. Consider using '#align with_bot.decidable_le WithBot.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
   | none, x => isTrue fun a h => Option.noConfusion h
@@ -707,7 +707,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4364 : α) (x._@.Mathlib.Order.WithBot._hyg.4366 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4364 x._@.Mathlib.Order.WithBot._hyg.4366)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4384 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4386 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4384 x._@.Mathlib.Order.WithBot._hyg.4386)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4385 : α) (x._@.Mathlib.Order.WithBot._hyg.4387 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4385 x._@.Mathlib.Order.WithBot._hyg.4387)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4405 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4407 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4405 x._@.Mathlib.Order.WithBot._hyg.4407)
 Case conversion may be inaccurate. Consider using '#align with_bot.decidable_lt WithBot.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
   | none, some x => isTrue <| by exists x, rfl <;> rintro _ ⟨⟩
@@ -719,7 +719,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithB
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4563 : α) (x._@.Mathlib.Order.WithBot._hyg.4565 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4563 x._@.Mathlib.Order.WithBot._hyg.4565)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4583 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4585 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4583 x._@.Mathlib.Order.WithBot._hyg.4585)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4585 : α) (x._@.Mathlib.Order.WithBot._hyg.4587 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4585 x._@.Mathlib.Order.WithBot._hyg.4587)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4605 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4607 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4605 x._@.Mathlib.Order.WithBot._hyg.4607)
 Case conversion may be inaccurate. Consider using '#align with_bot.is_total_le WithBot.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithBot α) (· ≤ ·) :=
   ⟨fun a b =>
@@ -760,7 +760,7 @@ theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = ma
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4766 : α) (x._@.Mathlib.Order.WithBot._hyg.4768 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4766 x._@.Mathlib.Order.WithBot._hyg.4768)) -> (WellFounded.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4786 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4788 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.4786 x._@.Mathlib.Order.WithBot._hyg.4788))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4789 : α) (x._@.Mathlib.Order.WithBot._hyg.4791 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4789 x._@.Mathlib.Order.WithBot._hyg.4791)) -> (WellFounded.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4809 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4811 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.4809 x._@.Mathlib.Order.WithBot._hyg.4811))
 Case conversion may be inaccurate. Consider using '#align with_bot.well_founded_lt WithBot.wellFounded_ltₓ'. -/
 theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithBot α) (· < ·) :=
@@ -1102,7 +1102,7 @@ theorem map_comm {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithBot.{u1} α), Eq.{succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithTop.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a)) (WithBot.map.{u1, u2} α (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} α β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) f) a)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithBot.{u2} α), Eq.{succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.{u2} α) (fun (_x : WithBot.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u2} α) => WithTop.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.toDual.{u2} α) a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} (OrderDual.{u1} β)) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => OrderDual.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.toDual.{u1} (OrderDual.{u1} β))) f) a)
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithBot.{u2} α), Eq.{succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.{u2} α) (fun (_x : WithBot.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u2} α) => WithTop.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.toDual.{u2} α) a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} (OrderDual.{u1} β)) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => OrderDual.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.toDual.{u1} (OrderDual.{u1} β))) f) a)
 Case conversion may be inaccurate. Consider using '#align with_top.map_to_dual WithTop.map_toDualₓ'. -/
 theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithBot α) :
     map f (WithBot.toDual a) = a.map (toDual ∘ f) :=
@@ -1113,7 +1113,7 @@ theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithBot α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithBot.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithTop.{u2} β) (WithTop.map.{u1, u2} α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) β (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) f) a)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithBot.{u2} (OrderDual.{u2} α)), Eq.{succ u1} (WithTop.{u1} β) (WithTop.map.{u2, u1} α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.{u2} (OrderDual.{u2} α)) (fun (_x : WithBot.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u2} (OrderDual.{u2} α)) => WithTop.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.ofDual.{u2} α) a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) f) a)
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithBot.{u2} (OrderDual.{u2} α)), Eq.{succ u1} (WithTop.{u1} β) (WithTop.map.{u2, u1} α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.{u2} (OrderDual.{u2} α)) (fun (_x : WithBot.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u2} (OrderDual.{u2} α)) => WithTop.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.ofDual.{u2} α) a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) f) a)
 Case conversion may be inaccurate. Consider using '#align with_top.map_of_dual WithTop.map_ofDualₓ'. -/
 theorem map_ofDual (f : α → β) (a : WithBot αᵒᵈ) : map f (WithBot.ofDual a) = a.map (ofDual ∘ f) :=
   rfl
@@ -1123,7 +1123,7 @@ theorem map_ofDual (f : α → β) (a : WithBot αᵒᵈ) : map f (WithBot.ofDua
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithTop.{u1} α), Eq.{succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} β) (WithBot.{u2} (OrderDual.{u2} β))) (fun (_x : Equiv.{succ u2, succ u2} (WithTop.{u2} β) (WithBot.{u2} (OrderDual.{u2} β))) => (WithTop.{u2} β) -> (WithBot.{u2} (OrderDual.{u2} β))) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithTop.{u2} β) (WithBot.{u2} (OrderDual.{u2} β))) (WithTop.toDual.{u2} β) (WithTop.map.{u1, u2} α β f a)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} (OrderDual.{u1} α) α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithTop.{u2} α), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} β) => WithBot.{u1} (OrderDual.{u1} β)) (WithTop.map.{u2, u1} α β f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} β) (WithBot.{u1} (OrderDual.{u1} β))) (WithTop.{u1} β) (fun (_x : WithTop.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} β) => WithBot.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} β) (WithBot.{u1} (OrderDual.{u1} β))) (WithTop.toDual.{u1} β) (WithTop.map.{u2, u1} α β f a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) β (OrderDual.{u1} β) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} β (OrderDual.{u1} β)) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => OrderDual.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β (OrderDual.{u1} β)) (OrderDual.toDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} (OrderDual.{u2} α) α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.{u2} α) (fun (_x : OrderDual.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u2} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.{u2} α) (fun (_x : WithTop.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u2} α) => WithBot.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.toDual.{u2} α) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithTop.{u2} α), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} β) => WithBot.{u1} (OrderDual.{u1} β)) (WithTop.map.{u2, u1} α β f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} β) (WithBot.{u1} (OrderDual.{u1} β))) (WithTop.{u1} β) (fun (_x : WithTop.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} β) => WithBot.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} β) (WithBot.{u1} (OrderDual.{u1} β))) (WithTop.toDual.{u1} β) (WithTop.map.{u2, u1} α β f a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) β (OrderDual.{u1} β) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} β (OrderDual.{u1} β)) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => OrderDual.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β (OrderDual.{u1} β)) (OrderDual.toDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} (OrderDual.{u2} α) α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.{u2} α) (fun (_x : OrderDual.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u2} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.{u2} α) (fun (_x : WithTop.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u2} α) => WithBot.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.toDual.{u2} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.to_dual_map WithTop.toDual_mapₓ'. -/
 theorem toDual_map (f : α → β) (a : WithTop α) :
     WithTop.toDual (map f a) = WithBot.map (toDual ∘ f ∘ ofDual) a.toDual :=
@@ -1134,7 +1134,7 @@ theorem toDual_map (f : α → β) (a : WithTop α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithTop.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithBot.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithBot.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithBot.{u2} β)) => (WithTop.{u2} (OrderDual.{u2} β)) -> (WithBot.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithBot.{u2} β)) (WithTop.ofDual.{u2} β) (WithTop.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f a)) (WithBot.map.{u1, u2} α β (Function.comp.{succ u1, succ u2, succ u2} α (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} α (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithTop.{u2} (OrderDual.{u2} α)), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} β)) => WithBot.{u1} β) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithBot.{u1} β)) (WithTop.{u1} (OrderDual.{u1} β)) (fun (_x : WithTop.{u1} (OrderDual.{u1} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} β)) => WithBot.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithBot.{u1} β)) (WithTop.ofDual.{u1} β) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} α (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.{u2} (OrderDual.{u2} α)) (fun (_x : WithTop.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u2} (OrderDual.{u2} α)) => WithBot.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.ofDual.{u2} α) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithTop.{u2} (OrderDual.{u2} α)), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} β)) => WithBot.{u1} β) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithBot.{u1} β)) (WithTop.{u1} (OrderDual.{u1} β)) (fun (_x : WithTop.{u1} (OrderDual.{u1} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} β)) => WithBot.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithBot.{u1} β)) (WithTop.ofDual.{u1} β) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} α (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.{u2} (OrderDual.{u2} α)) (fun (_x : WithTop.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u2} (OrderDual.{u2} α)) => WithBot.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.ofDual.{u2} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.of_dual_map WithTop.ofDual_mapₓ'. -/
 theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithTop αᵒᵈ) :
     WithTop.ofDual (map f a) = WithBot.map (ofDual ∘ f ∘ toDual) a.ofDual :=
@@ -1192,7 +1192,7 @@ theorem toDual_le_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.le_to_dual_iff WithTop.le_toDual_iffₓ'. -/
 theorem le_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     a ≤ WithTop.toDual b ↔ b ≤ WithBot.ofDual a :=
@@ -1217,7 +1217,7 @@ theorem ofDual_le_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.le_of_dual_iff WithTop.le_ofDual_iffₓ'. -/
 theorem le_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     a ≤ WithTop.ofDual b ↔ b ≤ WithBot.toDual a :=
@@ -1345,7 +1345,7 @@ instance (priority := 10) : LT (WithTop α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) b) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) a) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) b) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) a) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) b) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_top.to_dual_lt_iff WithTop.toDual_lt_iffₓ'. -/
 theorem toDual_lt_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
     WithTop.toDual a < b ↔ WithBot.ofDual b < a :=
@@ -1356,7 +1356,7 @@ theorem toDual_lt_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.lt_to_dual_iff WithTop.lt_toDual_iffₓ'. -/
 theorem lt_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     a < WithTop.toDual b ↔ b < WithBot.ofDual a :=
@@ -1367,7 +1367,7 @@ theorem lt_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) b a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) a) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) b a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) a) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) b a)
 Case conversion may be inaccurate. Consider using '#align with_top.to_dual_lt_to_dual_iff WithTop.toDual_lt_toDual_iffₓ'. -/
 @[simp]
 theorem toDual_lt_toDual_iff {a b : WithTop α} : WithTop.toDual a < WithTop.toDual b ↔ b < a :=
@@ -1378,7 +1378,7 @@ theorem toDual_lt_toDual_iff {a b : WithTop α} : WithTop.toDual a < WithTop.toD
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) b) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) a) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) b) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) a) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) b) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_top.of_dual_lt_iff WithTop.ofDual_lt_iffₓ'. -/
 theorem ofDual_lt_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
     WithTop.ofDual a < b ↔ WithBot.toDual b < a :=
@@ -1389,7 +1389,7 @@ theorem ofDual_lt_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.lt_of_dual_iff WithTop.lt_ofDual_iffₓ'. -/
 theorem lt_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     a < WithTop.ofDual b ↔ b < WithBot.toDual a :=
@@ -1400,7 +1400,7 @@ theorem lt_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) a) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) a) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b a)
 Case conversion may be inaccurate. Consider using '#align with_top.of_dual_lt_of_dual_iff WithTop.ofDual_lt_ofDual_iffₓ'. -/
 @[simp]
 theorem ofDual_lt_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a < WithTop.ofDual b ↔ b < a :=
@@ -1461,7 +1461,7 @@ theorem ofDual_apply_coe (a : αᵒᵈ) : WithBot.ofDual (a : WithBot αᵒᵈ)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithTop.{u1} α), Eq.{succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a)) (WithTop.map.{u1, u2} α (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} α β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) f) a)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithTop.{u2} α), Eq.{succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.{u2} α) (fun (_x : WithTop.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u2} α) => WithBot.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.toDual.{u2} α) a)) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} (OrderDual.{u1} β)) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => OrderDual.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.toDual.{u1} (OrderDual.{u1} β))) f) a)
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithTop.{u2} α), Eq.{succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.{u2} α) (fun (_x : WithTop.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u2} α) => WithBot.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.toDual.{u2} α) a)) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} (OrderDual.{u1} β)) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => OrderDual.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.toDual.{u1} (OrderDual.{u1} β))) f) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.map_to_dual WithBot.map_toDualₓ'. -/
 theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithTop α) :
     WithBot.map f (WithTop.toDual a) = a.map (toDual ∘ f) :=
@@ -1472,7 +1472,7 @@ theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithTop α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithTop.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithBot.{u2} β) (WithBot.map.{u1, u2} α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a)) (WithTop.map.{u1, u2} (OrderDual.{u1} α) β (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) f) a)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithTop.{u2} (OrderDual.{u2} α)), Eq.{succ u1} (WithBot.{u1} β) (WithBot.map.{u2, u1} α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.{u2} (OrderDual.{u2} α)) (fun (_x : WithTop.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u2} (OrderDual.{u2} α)) => WithBot.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.ofDual.{u2} α) a)) (WithTop.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) f) a)
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithTop.{u2} (OrderDual.{u2} α)), Eq.{succ u1} (WithBot.{u1} β) (WithBot.map.{u2, u1} α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.{u2} (OrderDual.{u2} α)) (fun (_x : WithTop.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u2} (OrderDual.{u2} α)) => WithBot.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.ofDual.{u2} α) a)) (WithTop.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) f) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.map_of_dual WithBot.map_ofDualₓ'. -/
 theorem map_ofDual (f : α → β) (a : WithTop αᵒᵈ) :
     WithBot.map f (WithTop.ofDual a) = a.map (ofDual ∘ f) :=
@@ -1483,7 +1483,7 @@ theorem map_ofDual (f : α → β) (a : WithTop αᵒᵈ) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithBot.{u1} α), Eq.{succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} β) (WithTop.{u2} (OrderDual.{u2} β))) (fun (_x : Equiv.{succ u2, succ u2} (WithBot.{u2} β) (WithTop.{u2} (OrderDual.{u2} β))) => (WithBot.{u2} β) -> (WithTop.{u2} (OrderDual.{u2} β))) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithBot.{u2} β) (WithTop.{u2} (OrderDual.{u2} β))) (WithBot.toDual.{u2} β) (WithBot.map.{u1, u2} α β f a)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} (OrderDual.{u1} α) α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithBot.{u2} α), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} β) => WithTop.{u1} (OrderDual.{u1} β)) (WithBot.map.{u2, u1} α β f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} β) (WithTop.{u1} (OrderDual.{u1} β))) (WithBot.{u1} β) (fun (_x : WithBot.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} β) => WithTop.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} β) (WithTop.{u1} (OrderDual.{u1} β))) (WithBot.toDual.{u1} β) (WithBot.map.{u2, u1} α β f a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) β (OrderDual.{u1} β) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} β (OrderDual.{u1} β)) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => OrderDual.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β (OrderDual.{u1} β)) (OrderDual.toDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} (OrderDual.{u2} α) α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.{u2} α) (fun (_x : OrderDual.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u2} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.{u2} α) (fun (_x : WithBot.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u2} α) => WithTop.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.toDual.{u2} α) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithBot.{u2} α), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} β) => WithTop.{u1} (OrderDual.{u1} β)) (WithBot.map.{u2, u1} α β f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} β) (WithTop.{u1} (OrderDual.{u1} β))) (WithBot.{u1} β) (fun (_x : WithBot.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} β) => WithTop.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} β) (WithTop.{u1} (OrderDual.{u1} β))) (WithBot.toDual.{u1} β) (WithBot.map.{u2, u1} α β f a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) β (OrderDual.{u1} β) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} β (OrderDual.{u1} β)) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : β) => OrderDual.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β (OrderDual.{u1} β)) (OrderDual.toDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} (OrderDual.{u2} α) α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.{u2} α) (fun (_x : OrderDual.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u2} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.{u2} α) (fun (_x : WithBot.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u2} α) => WithTop.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.toDual.{u2} α) a))
 Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_map WithBot.toDual_mapₓ'. -/
 theorem toDual_map (f : α → β) (a : WithBot α) :
     WithBot.toDual (WithBot.map f a) = map (toDual ∘ f ∘ ofDual) a.toDual :=
@@ -1494,7 +1494,7 @@ theorem toDual_map (f : α → β) (a : WithBot α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithBot.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithTop.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithTop.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithTop.{u2} β)) => (WithBot.{u2} (OrderDual.{u2} β)) -> (WithTop.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithTop.{u2} β)) (WithBot.ofDual.{u2} β) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f a)) (WithBot.map.{u1, u2} α β (Function.comp.{succ u1, succ u2, succ u2} α (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} α (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithBot.{u2} (OrderDual.{u2} α)), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} β)) => WithTop.{u1} β) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithTop.{u1} β)) (WithBot.{u1} (OrderDual.{u1} β)) (fun (_x : WithBot.{u1} (OrderDual.{u1} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} β)) => WithTop.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithTop.{u1} β)) (WithBot.ofDual.{u1} β) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} α (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.{u2} (OrderDual.{u2} α)) (fun (_x : WithBot.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u2} (OrderDual.{u2} α)) => WithTop.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.ofDual.{u2} α) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithBot.{u2} (OrderDual.{u2} α)), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} β)) => WithTop.{u1} β) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithTop.{u1} β)) (WithBot.{u1} (OrderDual.{u1} β)) (fun (_x : WithBot.{u1} (OrderDual.{u1} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} β)) => WithTop.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithTop.{u1} β)) (WithBot.ofDual.{u1} β) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} α (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.{u2} (OrderDual.{u2} α)) (fun (_x : WithBot.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u2} (OrderDual.{u2} α)) => WithTop.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.ofDual.{u2} α) a))
 Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_map WithBot.ofDual_mapₓ'. -/
 theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithBot αᵒᵈ) :
     WithBot.ofDual (WithBot.map f a) = map (ofDual ∘ f ∘ toDual) a.ofDual :=
@@ -1509,7 +1509,7 @@ variable [LE α] {a b : α}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) b) (WithBot.le.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) b) (WithBot.le.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_le_iff WithBot.toDual_le_iffₓ'. -/
 theorem toDual_le_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     WithBot.toDual a ≤ b ↔ WithTop.ofDual b ≤ a :=
@@ -1534,7 +1534,7 @@ theorem toDual_le_toDual_iff {a b : WithBot α} : WithBot.toDual a ≤ WithBot.t
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.le.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) b) (WithBot.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.le.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) b) (WithBot.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_le_iff WithBot.ofDual_le_iffₓ'. -/
 theorem ofDual_le_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     WithBot.ofDual a ≤ b ↔ WithTop.toDual b ≤ a :=
@@ -1565,7 +1565,7 @@ variable [LT α] {a b : α}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) b) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) b) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_lt_iff WithBot.toDual_lt_iffₓ'. -/
 theorem toDual_lt_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     WithBot.toDual a < b ↔ WithTop.ofDual b < a :=
@@ -1576,7 +1576,7 @@ theorem toDual_lt_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_bot.lt_to_dual_iff WithBot.lt_toDual_iffₓ'. -/
 theorem lt_toDual_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
     a < WithBot.toDual b ↔ b < WithTop.ofDual a :=
@@ -1587,7 +1587,7 @@ theorem lt_toDual_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) b a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) b a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) b a)
 Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_lt_to_dual_iff WithBot.toDual_lt_toDual_iffₓ'. -/
 @[simp]
 theorem toDual_lt_toDual_iff {a b : WithBot α} : WithBot.toDual a < WithBot.toDual b ↔ b < a :=
@@ -1598,7 +1598,7 @@ theorem toDual_lt_toDual_iff {a b : WithBot α} : WithBot.toDual a < WithBot.toD
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) b) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) b) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_lt_iff WithBot.ofDual_lt_iffₓ'. -/
 theorem ofDual_lt_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     WithBot.ofDual a < b ↔ WithTop.toDual b < a :=
@@ -1609,7 +1609,7 @@ theorem ofDual_lt_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_bot.lt_of_dual_iff WithBot.lt_ofDual_iffₓ'. -/
 theorem lt_ofDual_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
     a < WithBot.ofDual b ↔ b < WithTop.toDual a :=
@@ -1620,7 +1620,7 @@ theorem lt_ofDual_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b a)
 Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_lt_of_dual_iff WithBot.ofDual_lt_ofDual_iffₓ'. -/
 @[simp]
 theorem ofDual_lt_ofDual_iff {a b : WithBot αᵒᵈ} : WithBot.ofDual a < WithBot.ofDual b ↔ b < a :=
@@ -1912,7 +1912,7 @@ instance [DistribLattice α] : DistribLattice (WithTop α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10386 : α) (x._@.Mathlib.Order.WithBot._hyg.10388 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10386 x._@.Mathlib.Order.WithBot._hyg.10388)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10406 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10408 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10406 x._@.Mathlib.Order.WithBot._hyg.10408)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10423 : α) (x._@.Mathlib.Order.WithBot._hyg.10425 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10423 x._@.Mathlib.Order.WithBot._hyg.10425)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10443 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10445 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10443 x._@.Mathlib.Order.WithBot._hyg.10445)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_le WithTop.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithTop α) (· ≤ ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLE _ _) toDual_le_toDual_iff
@@ -1922,7 +1922,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10441 : α) (x._@.Mathlib.Order.WithBot._hyg.10443 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10441 x._@.Mathlib.Order.WithBot._hyg.10443)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10461 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10463 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10461 x._@.Mathlib.Order.WithBot._hyg.10463)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10478 : α) (x._@.Mathlib.Order.WithBot._hyg.10480 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10478 x._@.Mathlib.Order.WithBot._hyg.10480)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10498 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10500 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10498 x._@.Mathlib.Order.WithBot._hyg.10500)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_lt WithTop.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithTop α) (· < ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLT _ _) toDual_lt_toDual_iff
@@ -1932,7 +1932,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithT
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10496 : α) (x._@.Mathlib.Order.WithBot._hyg.10498 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10496 x._@.Mathlib.Order.WithBot._hyg.10498)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10516 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10518 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10516 x._@.Mathlib.Order.WithBot._hyg.10518)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10533 : α) (x._@.Mathlib.Order.WithBot._hyg.10535 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10533 x._@.Mathlib.Order.WithBot._hyg.10535)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10553 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10555 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10553 x._@.Mathlib.Order.WithBot._hyg.10555)
 Case conversion may be inaccurate. Consider using '#align with_top.is_total_le WithTop.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) :=
   ⟨fun _ _ => by
@@ -1969,7 +1969,7 @@ theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10643 : α) (x._@.Mathlib.Order.WithBot._hyg.10645 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10643 x._@.Mathlib.Order.WithBot._hyg.10645)) -> (WellFounded.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10663 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10665 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.10663 x._@.Mathlib.Order.WithBot._hyg.10665))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10680 : α) (x._@.Mathlib.Order.WithBot._hyg.10682 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10680 x._@.Mathlib.Order.WithBot._hyg.10682)) -> (WellFounded.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10700 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10702 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.10700 x._@.Mathlib.Order.WithBot._hyg.10702))
 Case conversion may be inaccurate. Consider using '#align with_top.well_founded_lt WithTop.wellFounded_ltₓ'. -/
 theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithTop α) (· < ·) :=
@@ -1995,7 +1995,7 @@ open OrderDual
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithTop.{u1} α) (GT.gt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10894 : α) (x._@.Mathlib.Order.WithBot._hyg.10896 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10894 x._@.Mathlib.Order.WithBot._hyg.10896)) -> (WellFounded.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10914 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10916 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.10914 x._@.Mathlib.Order.WithBot._hyg.10916))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10931 : α) (x._@.Mathlib.Order.WithBot._hyg.10933 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10931 x._@.Mathlib.Order.WithBot._hyg.10933)) -> (WellFounded.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10951 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10953 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.10951 x._@.Mathlib.Order.WithBot._hyg.10953))
 Case conversion may be inaccurate. Consider using '#align with_top.well_founded_gt WithTop.wellFounded_gtₓ'. -/
 theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithTop α) (· > ·) :=
@@ -2013,7 +2013,7 @@ theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithBot.{u1} α) (GT.gt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11053 : α) (x._@.Mathlib.Order.WithBot._hyg.11055 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11053 x._@.Mathlib.Order.WithBot._hyg.11055)) -> (WellFounded.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11073 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11075 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11073 x._@.Mathlib.Order.WithBot._hyg.11075))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11090 : α) (x._@.Mathlib.Order.WithBot._hyg.11092 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11090 x._@.Mathlib.Order.WithBot._hyg.11092)) -> (WellFounded.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11110 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11112 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11110 x._@.Mathlib.Order.WithBot._hyg.11112))
 Case conversion may be inaccurate. Consider using '#align with_bot.well_founded_gt WithBot.wellFounded_gtₓ'. -/
 theorem WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithBot α) (· > ·) :=
@@ -2031,7 +2031,7 @@ theorem WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11216 : α) (x._@.Mathlib.Order.WithBot._hyg.11218 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11216 x._@.Mathlib.Order.WithBot._hyg.11218)], IsTrichotomous.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11236 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11238 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11236 x._@.Mathlib.Order.WithBot._hyg.11238)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11253 : α) (x._@.Mathlib.Order.WithBot._hyg.11255 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11253 x._@.Mathlib.Order.WithBot._hyg.11255)], IsTrichotomous.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11273 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11275 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11273 x._@.Mathlib.Order.WithBot._hyg.11275)
 Case conversion may be inaccurate. Consider using '#align with_top.trichotomous.lt WithTop.trichotomous.ltₓ'. -/
 instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithTop α) (· < ·) :=
@@ -2045,7 +2045,7 @@ instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11309 : α) (x._@.Mathlib.Order.WithBot._hyg.11311 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11309 x._@.Mathlib.Order.WithBot._hyg.11311)], IsWellOrder.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11329 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11331 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11329 x._@.Mathlib.Order.WithBot._hyg.11331)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11346 : α) (x._@.Mathlib.Order.WithBot._hyg.11348 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11346 x._@.Mathlib.Order.WithBot._hyg.11348)], IsWellOrder.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11366 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11368 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11366 x._@.Mathlib.Order.WithBot._hyg.11368)
 Case conversion may be inaccurate. Consider using '#align with_top.is_well_order.lt WithTop.IsWellOrder.ltₓ'. -/
 instance IsWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] : IsWellOrder (WithTop α) (· < ·)
     where wf := wellFounded_lt h.wf
@@ -2055,7 +2055,7 @@ instance IsWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] : IsWellOrd
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithTop.{u1} α) (GT.gt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11366 : α) (x._@.Mathlib.Order.WithBot._hyg.11368 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11366 x._@.Mathlib.Order.WithBot._hyg.11368)], IsTrichotomous.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11386 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11388 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11386 x._@.Mathlib.Order.WithBot._hyg.11388)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11403 : α) (x._@.Mathlib.Order.WithBot._hyg.11405 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11403 x._@.Mathlib.Order.WithBot._hyg.11405)], IsTrichotomous.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11423 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11425 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11423 x._@.Mathlib.Order.WithBot._hyg.11425)
 Case conversion may be inaccurate. Consider using '#align with_top.trichotomous.gt WithTop.trichotomous.gtₓ'. -/
 instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     IsTrichotomous (WithTop α) (· > ·) :=
@@ -2069,7 +2069,7 @@ instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithTop.{u1} α) (GT.gt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11459 : α) (x._@.Mathlib.Order.WithBot._hyg.11461 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11459 x._@.Mathlib.Order.WithBot._hyg.11461)], IsWellOrder.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11479 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11481 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11479 x._@.Mathlib.Order.WithBot._hyg.11481)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11496 : α) (x._@.Mathlib.Order.WithBot._hyg.11498 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11496 x._@.Mathlib.Order.WithBot._hyg.11498)], IsWellOrder.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11516 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11518 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11516 x._@.Mathlib.Order.WithBot._hyg.11518)
 Case conversion may be inaccurate. Consider using '#align with_top.is_well_order.gt WithTop.IsWellOrder.gtₓ'. -/
 instance IsWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] : IsWellOrder (WithTop α) (· > ·)
     where wf := wellFounded_gt h.wf
@@ -2079,7 +2079,7 @@ instance IsWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] : IsWellOrd
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11512 : α) (x._@.Mathlib.Order.WithBot._hyg.11514 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11512 x._@.Mathlib.Order.WithBot._hyg.11514)], IsTrichotomous.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11532 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11534 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11532 x._@.Mathlib.Order.WithBot._hyg.11534)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11549 : α) (x._@.Mathlib.Order.WithBot._hyg.11551 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11549 x._@.Mathlib.Order.WithBot._hyg.11551)], IsTrichotomous.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11569 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11571 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11569 x._@.Mathlib.Order.WithBot._hyg.11571)
 Case conversion may be inaccurate. Consider using '#align with_bot.trichotomous.lt WithBot.trichotomous.ltₓ'. -/
 instance WithBot.trichotomous.lt [Preorder α] [h : IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithBot α) (· < ·) :=
@@ -2090,7 +2090,7 @@ instance WithBot.trichotomous.lt [Preorder α] [h : IsTrichotomous α (· < ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11564 : α) (x._@.Mathlib.Order.WithBot._hyg.11566 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11564 x._@.Mathlib.Order.WithBot._hyg.11566)], IsWellOrder.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11584 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11586 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11584 x._@.Mathlib.Order.WithBot._hyg.11586)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11601 : α) (x._@.Mathlib.Order.WithBot._hyg.11603 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11601 x._@.Mathlib.Order.WithBot._hyg.11603)], IsWellOrder.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11621 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11623 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11621 x._@.Mathlib.Order.WithBot._hyg.11623)
 Case conversion may be inaccurate. Consider using '#align with_bot.is_well_order.lt WithBot.isWellOrder.ltₓ'. -/
 instance WithBot.isWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] :
     IsWellOrder (WithBot α) (· < ·) :=
@@ -2101,7 +2101,7 @@ instance WithBot.isWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithBot.{u1} α) (GT.gt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11616 : α) (x._@.Mathlib.Order.WithBot._hyg.11618 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11616 x._@.Mathlib.Order.WithBot._hyg.11618)], IsTrichotomous.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11636 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11638 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11636 x._@.Mathlib.Order.WithBot._hyg.11638)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11653 : α) (x._@.Mathlib.Order.WithBot._hyg.11655 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11653 x._@.Mathlib.Order.WithBot._hyg.11655)], IsTrichotomous.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11673 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11675 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11673 x._@.Mathlib.Order.WithBot._hyg.11675)
 Case conversion may be inaccurate. Consider using '#align with_bot.trichotomous.gt WithBot.trichotomous.gtₓ'. -/
 instance WithBot.trichotomous.gt [Preorder α] [h : IsTrichotomous α (· > ·)] :
     IsTrichotomous (WithBot α) (· > ·) :=
@@ -2112,7 +2112,7 @@ instance WithBot.trichotomous.gt [Preorder α] [h : IsTrichotomous α (· > ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithBot.{u1} α) (GT.gt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11668 : α) (x._@.Mathlib.Order.WithBot._hyg.11670 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11668 x._@.Mathlib.Order.WithBot._hyg.11670)], IsWellOrder.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11688 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11690 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11688 x._@.Mathlib.Order.WithBot._hyg.11690)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11705 : α) (x._@.Mathlib.Order.WithBot._hyg.11707 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11705 x._@.Mathlib.Order.WithBot._hyg.11707)], IsWellOrder.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11725 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11727 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11725 x._@.Mathlib.Order.WithBot._hyg.11727)
 Case conversion may be inaccurate. Consider using '#align with_bot.is_well_order.gt WithBot.isWellOrder.gtₓ'. -/
 instance WithBot.isWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] :
     IsWellOrder (WithBot α) (· > ·) :=

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -508,7 +508,7 @@ theorem coe_mono [Preorder α] : Monotone (coe : α → WithBot α) := fun a b =
 
 /- warning: with_bot.monotone_iff -> WithBot.monotone_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithBot.{u1} α) -> β}, Iff (Monotone.{u1, u2} (WithBot.{u1} α) β (WithBot.preorder.{u1} α _inst_1) _inst_2 f) (And (Monotone.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithBot.{u1} α) β f ((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} α)))))) (forall (x : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (f ((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} α))) x))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithBot.{u1} α) -> β}, Iff (Monotone.{u1, u2} (WithBot.{u1} α) β (WithBot.preorder.{u1} α _inst_1) _inst_2 f) (And (Monotone.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithBot.{u1} α) β f ((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} α)))))) (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (f ((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} α))) x))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : (WithBot.{u2} α) -> β}, Iff (Monotone.{u2, u1} (WithBot.{u2} α) β (WithBot.preorder.{u2} α _inst_1) _inst_2 f) (And (Monotone.{u2, u1} α β _inst_1 _inst_2 (fun (a : α) => f (WithBot.some.{u2} α a))) (forall (x : α), LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f (Bot.bot.{u2} (WithBot.{u2} α) (WithBot.bot.{u2} α))) (f (WithBot.some.{u2} α x))))
 Case conversion may be inaccurate. Consider using '#align with_bot.monotone_iff WithBot.monotone_iffₓ'. -/
@@ -543,7 +543,7 @@ alias monotone_map_iff ↔ _ _root_.monotone.with_bot_map
 
 /- warning: with_bot.strict_mono_iff -> WithBot.strictMono_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithBot.{u1} α) -> β}, Iff (StrictMono.{u1, u2} (WithBot.{u1} α) β (WithBot.preorder.{u1} α _inst_1) _inst_2 f) (And (StrictMono.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithBot.{u1} α) β f ((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} α)))))) (forall (x : α), LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (f ((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} α))) x))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithBot.{u1} α) -> β}, Iff (StrictMono.{u1, u2} (WithBot.{u1} α) β (WithBot.preorder.{u1} α _inst_1) _inst_2 f) (And (StrictMono.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithBot.{u1} α) β f ((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} α)))))) (forall (x : α), LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (f ((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} α))) x))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : (WithBot.{u2} α) -> β}, Iff (StrictMono.{u2, u1} (WithBot.{u2} α) β (WithBot.preorder.{u2} α _inst_1) _inst_2 f) (And (StrictMono.{u2, u1} α β _inst_1 _inst_2 (fun (a : α) => f (WithBot.some.{u2} α a))) (forall (x : α), LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (f (Bot.bot.{u2} (WithBot.{u2} α) (WithBot.bot.{u2} α))) (f (WithBot.some.{u2} α x))))
 Case conversion may be inaccurate. Consider using '#align with_bot.strict_mono_iff WithBot.strictMono_iffₓ'. -/
@@ -578,7 +578,7 @@ alias strict_mono_map_iff ↔ _ _root_.strict_mono.with_bot_map
 
 /- warning: with_bot.map_le_iff -> WithBot.map_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β), (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)) -> (forall (a : WithBot.{u1} α) (b : WithBot.{u1} α), Iff (LE.le.{u2} (WithBot.{u2} β) (Preorder.toLE.{u2} (WithBot.{u2} β) (WithBot.preorder.{u2} β _inst_2)) (WithBot.map.{u1, u2} α β f a) (WithBot.map.{u1, u2} α β f b)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β), (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)) -> (forall (a : WithBot.{u1} α) (b : WithBot.{u1} α), Iff (LE.le.{u2} (WithBot.{u2} β) (Preorder.toHasLe.{u2} (WithBot.{u2} β) (WithBot.preorder.{u2} β _inst_2)) (WithBot.map.{u1, u2} α β f a) (WithBot.map.{u1, u2} α β f b)) (LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] (f : α -> β), (forall {a : α} {b : α}, Iff (LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f a) (f b)) (LE.le.{u2} α (Preorder.toLE.{u2} α _inst_1) a b)) -> (forall (a : WithBot.{u2} α) (b : WithBot.{u2} α), Iff (LE.le.{u1} (WithBot.{u1} β) (Preorder.toLE.{u1} (WithBot.{u1} β) (WithBot.preorder.{u1} β _inst_2)) (WithBot.map.{u2, u1} α β f a) (WithBot.map.{u2, u1} α β f b)) (LE.le.{u2} (WithBot.{u2} α) (Preorder.toLE.{u2} (WithBot.{u2} α) (WithBot.preorder.{u2} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align with_bot.map_le_iff WithBot.map_le_iffₓ'. -/
@@ -589,12 +589,16 @@ theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {
   | (a : α), (b : α) => by simpa only [map_coe, coe_le_coe] using mono_iff
 #align with_bot.map_le_iff WithBot.map_le_iff
 
-#print WithBot.le_coe_unbot' /-
+/- warning: with_bot.le_coe_unbot' -> WithBot.le_coe_unbot' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : WithBot.{u1} α) (b : α), LE.le.{u1} (WithBot.{u1} α) (Preorder.toHasLe.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a ((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} α))) (WithBot.unbot'.{u1} α b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (a : WithBot.{u1} α) (b : α), LE.le.{u1} (WithBot.{u1} α) (Preorder.toLE.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a (WithBot.some.{u1} α (WithBot.unbot'.{u1} α b a))
+Case conversion may be inaccurate. Consider using '#align with_bot.le_coe_unbot' WithBot.le_coe_unbot'ₓ'. -/
 theorem le_coe_unbot' [Preorder α] : ∀ (a : WithBot α) (b : α), a ≤ a.unbot' b
   | (a : α), b => le_rfl
   | ⊥, b => bot_le
 #align with_bot.le_coe_unbot' WithBot.le_coe_unbot'
--/
 
 /- warning: with_bot.unbot'_bot_le_iff -> WithBot.unbot'_bot_le_iff is a dubious translation:
 lean 3 declaration is
@@ -691,7 +695,7 @@ instance [DistribLattice α] : DistribLattice (WithBot α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4186 : α) (x._@.Mathlib.Order.WithBot._hyg.4188 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4186 x._@.Mathlib.Order.WithBot._hyg.4188)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4206 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4208 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4206 x._@.Mathlib.Order.WithBot._hyg.4208)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4202 : α) (x._@.Mathlib.Order.WithBot._hyg.4204 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4202 x._@.Mathlib.Order.WithBot._hyg.4204)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4222 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4224 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4222 x._@.Mathlib.Order.WithBot._hyg.4224)
 Case conversion may be inaccurate. Consider using '#align with_bot.decidable_le WithBot.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
   | none, x => isTrue fun a h => Option.noConfusion h
@@ -703,7 +707,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4348 : α) (x._@.Mathlib.Order.WithBot._hyg.4350 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4348 x._@.Mathlib.Order.WithBot._hyg.4350)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4368 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4370 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4368 x._@.Mathlib.Order.WithBot._hyg.4370)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4364 : α) (x._@.Mathlib.Order.WithBot._hyg.4366 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4364 x._@.Mathlib.Order.WithBot._hyg.4366)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4384 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4386 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4384 x._@.Mathlib.Order.WithBot._hyg.4386)
 Case conversion may be inaccurate. Consider using '#align with_bot.decidable_lt WithBot.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
   | none, some x => isTrue <| by exists x, rfl <;> rintro _ ⟨⟩
@@ -715,7 +719,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithB
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4547 : α) (x._@.Mathlib.Order.WithBot._hyg.4549 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4547 x._@.Mathlib.Order.WithBot._hyg.4549)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4567 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4569 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4567 x._@.Mathlib.Order.WithBot._hyg.4569)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4563 : α) (x._@.Mathlib.Order.WithBot._hyg.4565 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4563 x._@.Mathlib.Order.WithBot._hyg.4565)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4583 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4585 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4583 x._@.Mathlib.Order.WithBot._hyg.4585)
 Case conversion may be inaccurate. Consider using '#align with_bot.is_total_le WithBot.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithBot α) (· ≤ ·) :=
   ⟨fun a b =>
@@ -752,7 +756,12 @@ theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = ma
   rfl
 #align with_bot.coe_max WithBot.coe_max
 
-#print WithBot.wellFounded_lt /-
+/- warning: with_bot.well_founded_lt -> WithBot.wellFounded_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4766 : α) (x._@.Mathlib.Order.WithBot._hyg.4768 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4766 x._@.Mathlib.Order.WithBot._hyg.4768)) -> (WellFounded.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4786 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4788 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.4786 x._@.Mathlib.Order.WithBot._hyg.4788))
+Case conversion may be inaccurate. Consider using '#align with_bot.well_founded_lt WithBot.wellFounded_ltₓ'. -/
 theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithBot α) (· < ·) :=
   have acc_bot : Acc ((· < ·) : WithBot α → WithBot α → Prop) ⊥ :=
@@ -772,7 +781,6 @@ theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
                 Option.recOn c (fun _ => acc_bot) fun c hc =>
                   ih _ (some_lt_some.1 hc) (lt_trans hc hba))⟩
 #align with_bot.well_founded_lt WithBot.wellFounded_lt
--/
 
 instance [LT α] [DenselyOrdered α] [NoMinOrder α] : DenselyOrdered (WithBot α) :=
   ⟨fun a b =>
@@ -785,7 +793,12 @@ instance [LT α] [DenselyOrdered α] [NoMinOrder α] : DenselyOrdered (WithBot 
       let ⟨a, ha₁, ha₂⟩ := exists_between (coe_lt_coe.1 h)
       ⟨a, coe_lt_coe.2 ha₁, coe_lt_coe.2 ha₂⟩⟩
 
-#print WithBot.lt_iff_exists_coe_btwn /-
+/- warning: with_bot.lt_iff_exists_coe_btwn -> WithBot.lt_iff_exists_coe_btwn is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DenselyOrdered.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (x : α) => And (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a ((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} α))) x)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{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} α))) x) b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DenselyOrdered.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (x : α) => And (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) a (WithBot.some.{u1} α x)) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) (WithBot.some.{u1} α x) b)))
+Case conversion may be inaccurate. Consider using '#align with_bot.lt_iff_exists_coe_btwn WithBot.lt_iff_exists_coe_btwnₓ'. -/
 theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMinOrder α] {a b : WithBot α} :
     a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b :=
   ⟨fun h =>
@@ -794,7 +807,6 @@ theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMinOrder α]
     ⟨x, hx.1 ▸ hy⟩,
     fun ⟨x, hx⟩ => lt_trans hx.1 hx.2⟩
 #align with_bot.lt_iff_exists_coe_btwn WithBot.lt_iff_exists_coe_btwn
--/
 
 instance [LE α] [NoTopOrder α] [Nonempty α] : NoTopOrder (WithBot α) :=
   ⟨by
@@ -1750,7 +1762,7 @@ theorem coe_mono [Preorder α] : Monotone (coe : α → WithTop α) := fun a b =
 
 /- warning: with_top.monotone_iff -> WithTop.monotone_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithTop.{u1} α) -> β}, Iff (Monotone.{u1, u2} (WithTop.{u1} α) β (WithTop.preorder.{u1} α _inst_1) _inst_2 f) (And (Monotone.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithTop.{u1} α) β f ((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} α)))))) (forall (x : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f ((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} α))) x)) (f (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithTop.{u1} α) -> β}, Iff (Monotone.{u1, u2} (WithTop.{u1} α) β (WithTop.preorder.{u1} α _inst_1) _inst_2 f) (And (Monotone.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithTop.{u1} α) β f ((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} α)))))) (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f ((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} α))) x)) (f (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : (WithTop.{u2} α) -> β}, Iff (Monotone.{u2, u1} (WithTop.{u2} α) β (WithTop.preorder.{u2} α _inst_1) _inst_2 f) (And (Monotone.{u2, u1} α β _inst_1 _inst_2 (fun (a : α) => f (WithTop.some.{u2} α a))) (forall (x : α), LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f (WithTop.some.{u2} α x)) (f (Top.top.{u2} (WithTop.{u2} α) (WithTop.top.{u2} α)))))
 Case conversion may be inaccurate. Consider using '#align with_top.monotone_iff WithTop.monotone_iffₓ'. -/
@@ -1785,7 +1797,7 @@ alias monotone_map_iff ↔ _ _root_.monotone.with_top_map
 
 /- warning: with_top.strict_mono_iff -> WithTop.strictMono_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithTop.{u1} α) -> β}, Iff (StrictMono.{u1, u2} (WithTop.{u1} α) β (WithTop.preorder.{u1} α _inst_1) _inst_2 f) (And (StrictMono.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithTop.{u1} α) β f ((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} α)))))) (forall (x : α), LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f ((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} α))) x)) (f (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : (WithTop.{u1} α) -> β}, Iff (StrictMono.{u1, u2} (WithTop.{u1} α) β (WithTop.preorder.{u1} α _inst_1) _inst_2 f) (And (StrictMono.{u1, u2} α β _inst_1 _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (WithTop.{u1} α) β f ((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} α)))))) (forall (x : α), LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f ((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} α))) x)) (f (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : (WithTop.{u2} α) -> β}, Iff (StrictMono.{u2, u1} (WithTop.{u2} α) β (WithTop.preorder.{u2} α _inst_1) _inst_2 f) (And (StrictMono.{u2, u1} α β _inst_1 _inst_2 (fun (a : α) => f (WithTop.some.{u2} α a))) (forall (x : α), LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (f (WithTop.some.{u2} α x)) (f (Top.top.{u2} (WithTop.{u2} α) (WithTop.top.{u2} α)))))
 Case conversion may be inaccurate. Consider using '#align with_top.strict_mono_iff WithTop.strictMono_iffₓ'. -/
@@ -1820,7 +1832,7 @@ alias strict_mono_map_iff ↔ _ _root_.strict_mono.with_top_map
 
 /- warning: with_top.map_le_iff -> WithTop.map_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β) (a : WithTop.{u1} α) (b : WithTop.{u1} α), (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)) -> (Iff (LE.le.{u2} (WithTop.{u2} β) (Preorder.toLE.{u2} (WithTop.{u2} β) (WithTop.preorder.{u2} β _inst_2)) (WithTop.map.{u1, u2} α β f a) (WithTop.map.{u1, u2} α β f b)) (LE.le.{u1} (WithTop.{u1} α) (Preorder.toLE.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β) (a : WithTop.{u1} α) (b : WithTop.{u1} α), (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)) -> (Iff (LE.le.{u2} (WithTop.{u2} β) (Preorder.toHasLe.{u2} (WithTop.{u2} β) (WithTop.preorder.{u2} β _inst_2)) (WithTop.map.{u1, u2} α β f a) (WithTop.map.{u1, u2} α β f b)) (LE.le.{u1} (WithTop.{u1} α) (Preorder.toHasLe.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] (f : α -> β) (a : WithTop.{u2} α) (b : WithTop.{u2} α), (forall {a : α} {b : α}, Iff (LE.le.{u1} β (Preorder.toLE.{u1} β _inst_2) (f a) (f b)) (LE.le.{u2} α (Preorder.toLE.{u2} α _inst_1) a b)) -> (Iff (LE.le.{u1} (WithTop.{u1} β) (Preorder.toLE.{u1} (WithTop.{u1} β) (WithTop.preorder.{u1} β _inst_2)) (WithTop.map.{u2, u1} α β f a) (WithTop.map.{u2, u1} α β f b)) (LE.le.{u2} (WithTop.{u2} α) (Preorder.toLE.{u2} (WithTop.{u2} α) (WithTop.preorder.{u2} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align with_top.map_le_iff WithTop.map_le_iffₓ'. -/
@@ -1900,7 +1912,7 @@ instance [DistribLattice α] : DistribLattice (WithTop α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10356 : α) (x._@.Mathlib.Order.WithBot._hyg.10358 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10356 x._@.Mathlib.Order.WithBot._hyg.10358)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10376 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10378 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10376 x._@.Mathlib.Order.WithBot._hyg.10378)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10386 : α) (x._@.Mathlib.Order.WithBot._hyg.10388 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10386 x._@.Mathlib.Order.WithBot._hyg.10388)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10406 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10408 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10406 x._@.Mathlib.Order.WithBot._hyg.10408)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_le WithTop.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithTop α) (· ≤ ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLE _ _) toDual_le_toDual_iff
@@ -1910,7 +1922,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10411 : α) (x._@.Mathlib.Order.WithBot._hyg.10413 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10411 x._@.Mathlib.Order.WithBot._hyg.10413)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10431 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10433 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10431 x._@.Mathlib.Order.WithBot._hyg.10433)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10441 : α) (x._@.Mathlib.Order.WithBot._hyg.10443 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10441 x._@.Mathlib.Order.WithBot._hyg.10443)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10461 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10463 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10461 x._@.Mathlib.Order.WithBot._hyg.10463)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_lt WithTop.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithTop α) (· < ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLT _ _) toDual_lt_toDual_iff
@@ -1920,7 +1932,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithT
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10466 : α) (x._@.Mathlib.Order.WithBot._hyg.10468 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10466 x._@.Mathlib.Order.WithBot._hyg.10468)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10486 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10488 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10486 x._@.Mathlib.Order.WithBot._hyg.10488)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10496 : α) (x._@.Mathlib.Order.WithBot._hyg.10498 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10496 x._@.Mathlib.Order.WithBot._hyg.10498)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10516 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10518 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10516 x._@.Mathlib.Order.WithBot._hyg.10518)
 Case conversion may be inaccurate. Consider using '#align with_top.is_total_le WithTop.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) :=
   ⟨fun _ _ => by
@@ -1953,7 +1965,12 @@ theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max
   rfl
 #align with_top.coe_max WithTop.coe_max
 
-#print WithTop.wellFounded_lt /-
+/- warning: with_top.well_founded_lt -> WithTop.wellFounded_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10643 : α) (x._@.Mathlib.Order.WithBot._hyg.10645 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10643 x._@.Mathlib.Order.WithBot._hyg.10645)) -> (WellFounded.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10663 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10665 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.10663 x._@.Mathlib.Order.WithBot._hyg.10665))
+Case conversion may be inaccurate. Consider using '#align with_top.well_founded_lt WithTop.wellFounded_ltₓ'. -/
 theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithTop α) (· < ·) :=
   have acc_some : ∀ a : α, Acc ((· < ·) : WithTop α → WithTop α → Prop) (some a) := fun a =>
@@ -1971,11 +1988,15 @@ theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
       (Acc.intro _ fun y => Option.recOn y (fun h => (lt_irrefl _ h).elim) fun _ _ => acc_some _)
       acc_some⟩
 #align with_top.well_founded_lt WithTop.wellFounded_lt
--/
 
 open OrderDual
 
-#print WithTop.wellFounded_gt /-
+/- warning: with_top.well_founded_gt -> WithTop.wellFounded_gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithTop.{u1} α) (GT.gt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10894 : α) (x._@.Mathlib.Order.WithBot._hyg.10896 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10894 x._@.Mathlib.Order.WithBot._hyg.10896)) -> (WellFounded.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10914 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10916 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.10914 x._@.Mathlib.Order.WithBot._hyg.10916))
+Case conversion may be inaccurate. Consider using '#align with_top.well_founded_gt WithTop.wellFounded_gtₓ'. -/
 theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithTop α) (· > ·) :=
   ⟨fun a =>
@@ -1987,9 +2008,13 @@ theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     induction' ac with _ H IH generalizing a; subst ha
     exact ⟨_, fun a' h => IH a'.toDual (to_dual_lt_to_dual.mpr h) _ rfl⟩⟩
 #align with_top.well_founded_gt WithTop.wellFounded_gt
--/
 
-#print WithBot.wellFounded_gt /-
+/- warning: with_bot.well_founded_gt -> WithBot.wellFounded_gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))) -> (WellFounded.{succ u1} (WithBot.{u1} α) (GT.gt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], (WellFounded.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11053 : α) (x._@.Mathlib.Order.WithBot._hyg.11055 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11053 x._@.Mathlib.Order.WithBot._hyg.11055)) -> (WellFounded.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11073 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11075 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11073 x._@.Mathlib.Order.WithBot._hyg.11075))
+Case conversion may be inaccurate. Consider using '#align with_bot.well_founded_gt WithBot.wellFounded_gtₓ'. -/
 theorem WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithBot α) (· > ·) :=
   ⟨fun a =>
@@ -2001,9 +2026,13 @@ theorem WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     induction' ac with _ H IH generalizing a; subst ha
     exact ⟨_, fun a' h => IH a'.toDual (to_dual_lt_to_dual.mpr h) _ rfl⟩⟩
 #align with_bot.well_founded_gt WithBot.wellFounded_gt
--/
 
-#print WithTop.trichotomous.lt /-
+/- warning: with_top.trichotomous.lt -> WithTop.trichotomous.lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11216 : α) (x._@.Mathlib.Order.WithBot._hyg.11218 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11216 x._@.Mathlib.Order.WithBot._hyg.11218)], IsTrichotomous.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11236 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11238 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11236 x._@.Mathlib.Order.WithBot._hyg.11238)
+Case conversion may be inaccurate. Consider using '#align with_top.trichotomous.lt WithTop.trichotomous.ltₓ'. -/
 instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithTop α) (· < ·) :=
   ⟨by
@@ -2011,15 +2040,23 @@ instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     iterate 3 simp
     simpa [Option.some_inj] using @trichotomous _ (· < ·) _ a b⟩
 #align with_top.trichotomous.lt WithTop.trichotomous.lt
--/
 
-#print WithTop.IsWellOrder.lt /-
+/- warning: with_top.is_well_order.lt -> WithTop.IsWellOrder.lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11309 : α) (x._@.Mathlib.Order.WithBot._hyg.11311 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11309 x._@.Mathlib.Order.WithBot._hyg.11311)], IsWellOrder.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11329 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11331 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11329 x._@.Mathlib.Order.WithBot._hyg.11331)
+Case conversion may be inaccurate. Consider using '#align with_top.is_well_order.lt WithTop.IsWellOrder.ltₓ'. -/
 instance IsWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] : IsWellOrder (WithTop α) (· < ·)
     where wf := wellFounded_lt h.wf
 #align with_top.is_well_order.lt WithTop.IsWellOrder.lt
--/
 
-#print WithTop.trichotomous.gt /-
+/- warning: with_top.trichotomous.gt -> WithTop.trichotomous.gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithTop.{u1} α) (GT.gt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11366 : α) (x._@.Mathlib.Order.WithBot._hyg.11368 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11366 x._@.Mathlib.Order.WithBot._hyg.11368)], IsTrichotomous.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11386 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11388 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11386 x._@.Mathlib.Order.WithBot._hyg.11388)
+Case conversion may be inaccurate. Consider using '#align with_top.trichotomous.gt WithTop.trichotomous.gtₓ'. -/
 instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     IsTrichotomous (WithTop α) (· > ·) :=
   ⟨by
@@ -2027,46 +2064,70 @@ instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     iterate 3 simp
     simpa [Option.some_inj] using @trichotomous _ (· > ·) _ a b⟩
 #align with_top.trichotomous.gt WithTop.trichotomous.gt
--/
 
-#print WithTop.IsWellOrder.gt /-
+/- warning: with_top.is_well_order.gt -> WithTop.IsWellOrder.gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithTop.{u1} α) (GT.gt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11459 : α) (x._@.Mathlib.Order.WithBot._hyg.11461 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11459 x._@.Mathlib.Order.WithBot._hyg.11461)], IsWellOrder.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11479 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11481 : WithTop.{u1} α) => GT.gt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11479 x._@.Mathlib.Order.WithBot._hyg.11481)
+Case conversion may be inaccurate. Consider using '#align with_top.is_well_order.gt WithTop.IsWellOrder.gtₓ'. -/
 instance IsWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] : IsWellOrder (WithTop α) (· > ·)
     where wf := wellFounded_gt h.wf
 #align with_top.is_well_order.gt WithTop.IsWellOrder.gt
--/
 
-#print WithBot.trichotomous.lt /-
+/- warning: with_bot.trichotomous.lt -> WithBot.trichotomous.lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11512 : α) (x._@.Mathlib.Order.WithBot._hyg.11514 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11512 x._@.Mathlib.Order.WithBot._hyg.11514)], IsTrichotomous.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11532 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11534 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11532 x._@.Mathlib.Order.WithBot._hyg.11534)
+Case conversion may be inaccurate. Consider using '#align with_bot.trichotomous.lt WithBot.trichotomous.ltₓ'. -/
 instance WithBot.trichotomous.lt [Preorder α] [h : IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithBot α) (· < ·) :=
   @WithTop.trichotomous.gt αᵒᵈ _ h
 #align with_bot.trichotomous.lt WithBot.trichotomous.lt
--/
 
-#print WithBot.isWellOrder.lt /-
+/- warning: with_bot.is_well_order.lt -> WithBot.isWellOrder.lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11564 : α) (x._@.Mathlib.Order.WithBot._hyg.11566 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11564 x._@.Mathlib.Order.WithBot._hyg.11566)], IsWellOrder.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11584 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11586 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11584 x._@.Mathlib.Order.WithBot._hyg.11586)
+Case conversion may be inaccurate. Consider using '#align with_bot.is_well_order.lt WithBot.isWellOrder.ltₓ'. -/
 instance WithBot.isWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] :
     IsWellOrder (WithBot α) (· < ·) :=
   @WithTop.IsWellOrder.gt αᵒᵈ _ h
 #align with_bot.is_well_order.lt WithBot.isWellOrder.lt
--/
 
-#print WithBot.trichotomous.gt /-
+/- warning: with_bot.trichotomous.gt -> WithBot.trichotomous.gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsTrichotomous.{u1} (WithBot.{u1} α) (GT.gt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsTrichotomous.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11616 : α) (x._@.Mathlib.Order.WithBot._hyg.11618 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11616 x._@.Mathlib.Order.WithBot._hyg.11618)], IsTrichotomous.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11636 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11638 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11636 x._@.Mathlib.Order.WithBot._hyg.11638)
+Case conversion may be inaccurate. Consider using '#align with_bot.trichotomous.gt WithBot.trichotomous.gtₓ'. -/
 instance WithBot.trichotomous.gt [Preorder α] [h : IsTrichotomous α (· > ·)] :
     IsTrichotomous (WithBot α) (· > ·) :=
   @WithTop.trichotomous.lt αᵒᵈ _ h
 #align with_bot.trichotomous.gt WithBot.trichotomous.gt
--/
 
-#print WithBot.isWellOrder.gt /-
+/- warning: with_bot.is_well_order.gt -> WithBot.isWellOrder.gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))], IsWellOrder.{u1} (WithBot.{u1} α) (GT.gt.{u1} (WithBot.{u1} α) (Preorder.toHasLt.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.11668 : α) (x._@.Mathlib.Order.WithBot._hyg.11670 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.11668 x._@.Mathlib.Order.WithBot._hyg.11670)], IsWellOrder.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.11688 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.11690 : WithBot.{u1} α) => GT.gt.{u1} (WithBot.{u1} α) (Preorder.toLT.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)) x._@.Mathlib.Order.WithBot._hyg.11688 x._@.Mathlib.Order.WithBot._hyg.11690)
+Case conversion may be inaccurate. Consider using '#align with_bot.is_well_order.gt WithBot.isWellOrder.gtₓ'. -/
 instance WithBot.isWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] :
     IsWellOrder (WithBot α) (· > ·) :=
   @WithTop.IsWellOrder.lt αᵒᵈ _ h
 #align with_bot.is_well_order.gt WithBot.isWellOrder.gt
--/
 
 instance [LT α] [DenselyOrdered α] [NoMaxOrder α] : DenselyOrdered (WithTop α) :=
   OrderDual.denselyOrdered (WithBot αᵒᵈ)
 
-#print WithTop.lt_iff_exists_coe_btwn /-
+/- warning: with_top.lt_iff_exists_coe_btwn -> WithTop.lt_iff_exists_coe_btwn is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DenselyOrdered.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (x : α) => And (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a ((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} α))) x)) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toHasLt.{u1} (WithTop.{u1} α) (WithTop.preorder.{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} α))) x) b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DenselyOrdered.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a b) (Exists.{succ u1} α (fun (x : α) => And (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) a (WithTop.some.{u1} α x)) (LT.lt.{u1} (WithTop.{u1} α) (Preorder.toLT.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)) (WithTop.some.{u1} α x) b)))
+Case conversion may be inaccurate. Consider using '#align with_top.lt_iff_exists_coe_btwn WithTop.lt_iff_exists_coe_btwnₓ'. -/
 theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMaxOrder α] {a b : WithTop α} :
     a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b :=
   ⟨fun h =>
@@ -2075,7 +2136,6 @@ theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMaxOrder α]
     ⟨x, hx.1 ▸ hy⟩,
     fun ⟨x, hx⟩ => lt_trans hx.1 hx.2⟩
 #align with_top.lt_iff_exists_coe_btwn WithTop.lt_iff_exists_coe_btwn
--/
 
 instance [LE α] [NoBotOrder α] [Nonempty α] : NoBotOrder (WithTop α) :=
   OrderDual.noBotOrder (WithBot αᵒᵈ)

bump to nightly-2023-05-03-22

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

aa7b8e08

Diff

@@ -1900,7 +1900,7 @@ instance [DistribLattice α] : DistribLattice (WithTop α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10360 : α) (x._@.Mathlib.Order.WithBot._hyg.10362 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10360 x._@.Mathlib.Order.WithBot._hyg.10362)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10380 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10382 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10380 x._@.Mathlib.Order.WithBot._hyg.10382)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10356 : α) (x._@.Mathlib.Order.WithBot._hyg.10358 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10356 x._@.Mathlib.Order.WithBot._hyg.10358)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10376 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10378 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10376 x._@.Mathlib.Order.WithBot._hyg.10378)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_le WithTop.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithTop α) (· ≤ ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLE _ _) toDual_le_toDual_iff
@@ -1910,7 +1910,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10415 : α) (x._@.Mathlib.Order.WithBot._hyg.10417 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10415 x._@.Mathlib.Order.WithBot._hyg.10417)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10435 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10437 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10435 x._@.Mathlib.Order.WithBot._hyg.10437)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10411 : α) (x._@.Mathlib.Order.WithBot._hyg.10413 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10411 x._@.Mathlib.Order.WithBot._hyg.10413)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10431 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10433 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10431 x._@.Mathlib.Order.WithBot._hyg.10433)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_lt WithTop.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithTop α) (· < ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLT _ _) toDual_lt_toDual_iff
@@ -1920,7 +1920,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithT
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10470 : α) (x._@.Mathlib.Order.WithBot._hyg.10472 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10470 x._@.Mathlib.Order.WithBot._hyg.10472)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10490 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10492 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10490 x._@.Mathlib.Order.WithBot._hyg.10492)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10466 : α) (x._@.Mathlib.Order.WithBot._hyg.10468 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10466 x._@.Mathlib.Order.WithBot._hyg.10468)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10486 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10488 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10486 x._@.Mathlib.Order.WithBot._hyg.10488)
 Case conversion may be inaccurate. Consider using '#align with_top.is_total_le WithTop.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) :=
   ⟨fun _ _ => by

bump to nightly-2023-03-18-14

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

73d15350

Diff

@@ -691,7 +691,7 @@ instance [DistribLattice α] : DistribLattice (WithBot α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4170 : α) (x._@.Mathlib.Order.WithBot._hyg.4172 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4170 x._@.Mathlib.Order.WithBot._hyg.4172)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4190 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4192 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4190 x._@.Mathlib.Order.WithBot._hyg.4192)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4186 : α) (x._@.Mathlib.Order.WithBot._hyg.4188 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4186 x._@.Mathlib.Order.WithBot._hyg.4188)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4206 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4208 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4206 x._@.Mathlib.Order.WithBot._hyg.4208)
 Case conversion may be inaccurate. Consider using '#align with_bot.decidable_le WithBot.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
   | none, x => isTrue fun a h => Option.noConfusion h
@@ -703,7 +703,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4332 : α) (x._@.Mathlib.Order.WithBot._hyg.4334 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4332 x._@.Mathlib.Order.WithBot._hyg.4334)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4352 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4354 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4352 x._@.Mathlib.Order.WithBot._hyg.4354)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4348 : α) (x._@.Mathlib.Order.WithBot._hyg.4350 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4348 x._@.Mathlib.Order.WithBot._hyg.4350)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4368 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4370 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4368 x._@.Mathlib.Order.WithBot._hyg.4370)
 Case conversion may be inaccurate. Consider using '#align with_bot.decidable_lt WithBot.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
   | none, some x => isTrue <| by exists x, rfl <;> rintro _ ⟨⟩
@@ -715,7 +715,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithB
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4531 : α) (x._@.Mathlib.Order.WithBot._hyg.4533 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4531 x._@.Mathlib.Order.WithBot._hyg.4533)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4551 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4553 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4551 x._@.Mathlib.Order.WithBot._hyg.4553)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4547 : α) (x._@.Mathlib.Order.WithBot._hyg.4549 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4547 x._@.Mathlib.Order.WithBot._hyg.4549)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4567 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4569 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4567 x._@.Mathlib.Order.WithBot._hyg.4569)
 Case conversion may be inaccurate. Consider using '#align with_bot.is_total_le WithBot.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithBot α) (· ≤ ·) :=
   ⟨fun a b =>
@@ -1900,7 +1900,7 @@ instance [DistribLattice α] : DistribLattice (WithTop α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10328 : α) (x._@.Mathlib.Order.WithBot._hyg.10330 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10328 x._@.Mathlib.Order.WithBot._hyg.10330)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10348 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10350 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10348 x._@.Mathlib.Order.WithBot._hyg.10350)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10360 : α) (x._@.Mathlib.Order.WithBot._hyg.10362 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10360 x._@.Mathlib.Order.WithBot._hyg.10362)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10380 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10382 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10380 x._@.Mathlib.Order.WithBot._hyg.10382)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_le WithTop.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithTop α) (· ≤ ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLE _ _) toDual_le_toDual_iff
@@ -1910,7 +1910,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10383 : α) (x._@.Mathlib.Order.WithBot._hyg.10385 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10383 x._@.Mathlib.Order.WithBot._hyg.10385)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10403 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10405 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10403 x._@.Mathlib.Order.WithBot._hyg.10405)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10415 : α) (x._@.Mathlib.Order.WithBot._hyg.10417 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10415 x._@.Mathlib.Order.WithBot._hyg.10417)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10435 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10437 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10435 x._@.Mathlib.Order.WithBot._hyg.10437)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_lt WithTop.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithTop α) (· < ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLT _ _) toDual_lt_toDual_iff
@@ -1920,7 +1920,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithT
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10438 : α) (x._@.Mathlib.Order.WithBot._hyg.10440 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10438 x._@.Mathlib.Order.WithBot._hyg.10440)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10458 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10460 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10458 x._@.Mathlib.Order.WithBot._hyg.10460)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10470 : α) (x._@.Mathlib.Order.WithBot._hyg.10472 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10470 x._@.Mathlib.Order.WithBot._hyg.10472)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10490 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10492 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10490 x._@.Mathlib.Order.WithBot._hyg.10492)
 Case conversion may be inaccurate. Consider using '#align with_top.is_total_le WithTop.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) :=
   ⟨fun _ _ => by

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: Johannes Hölzl
 
 ! This file was ported from Lean 3 source module order.with_bot
-! 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.
 -/
@@ -64,6 +64,9 @@ unsafe instance {α : Type} [reflected _ α] [has_reflect α] : has_reflect (Wit
 instance : Inhabited (WithBot α) :=
   ⟨⊥⟩
 
+instance [Nonempty α] : Nontrivial (WithBot α) :=
+  Option.nontrivial
+
 open Function
 
 #print WithBot.coe_injective /-
@@ -849,6 +852,9 @@ unsafe instance {α : Type} [reflected _ α] [has_reflect α] : has_reflect (Wit
 instance : Inhabited (WithTop α) :=
   ⟨⊤⟩
 
+instance [Nonempty α] : Nontrivial (WithTop α) :=
+  Option.nontrivial
+
 #print WithTop.forall /-
 protected theorem forall {p : WithTop α → Prop} : (∀ x, p x) ↔ p ⊤ ∧ ∀ x : α, p x :=
   Option.forall

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -1084,7 +1084,7 @@ theorem map_comm {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithBot.{u1} α), Eq.{succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithTop.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a)) (WithBot.map.{u1, u2} α (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} α β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) f) a)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithBot.{u2} α), Eq.{succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.{u2} α) (fun (_x : WithBot.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u2} α) => WithTop.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.toDual.{u2} α) a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} (OrderDual.{u1} β)) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} β) => OrderDual.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.toDual.{u1} (OrderDual.{u1} β))) f) a)
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithBot.{u2} α), Eq.{succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.{u2} α) (fun (_x : WithBot.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u2} α) => WithTop.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.toDual.{u2} α) a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} (OrderDual.{u1} β)) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => OrderDual.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.toDual.{u1} (OrderDual.{u1} β))) f) a)
 Case conversion may be inaccurate. Consider using '#align with_top.map_to_dual WithTop.map_toDualₓ'. -/
 theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithBot α) :
     map f (WithBot.toDual a) = a.map (toDual ∘ f) :=
@@ -1095,7 +1095,7 @@ theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithBot α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithBot.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithTop.{u2} β) (WithTop.map.{u1, u2} α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) β (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) f) a)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithBot.{u2} (OrderDual.{u2} α)), Eq.{succ u1} (WithTop.{u1} β) (WithTop.map.{u2, u1} α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.{u2} (OrderDual.{u2} α)) (fun (_x : WithBot.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u2} (OrderDual.{u2} α)) => WithTop.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.ofDual.{u2} α) a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) f) a)
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithBot.{u2} (OrderDual.{u2} α)), Eq.{succ u1} (WithTop.{u1} β) (WithTop.map.{u2, u1} α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.{u2} (OrderDual.{u2} α)) (fun (_x : WithBot.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u2} (OrderDual.{u2} α)) => WithTop.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.ofDual.{u2} α) a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) f) a)
 Case conversion may be inaccurate. Consider using '#align with_top.map_of_dual WithTop.map_ofDualₓ'. -/
 theorem map_ofDual (f : α → β) (a : WithBot αᵒᵈ) : map f (WithBot.ofDual a) = a.map (ofDual ∘ f) :=
   rfl
@@ -1105,7 +1105,7 @@ theorem map_ofDual (f : α → β) (a : WithBot αᵒᵈ) : map f (WithBot.ofDua
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithTop.{u1} α), Eq.{succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} β) (WithBot.{u2} (OrderDual.{u2} β))) (fun (_x : Equiv.{succ u2, succ u2} (WithTop.{u2} β) (WithBot.{u2} (OrderDual.{u2} β))) => (WithTop.{u2} β) -> (WithBot.{u2} (OrderDual.{u2} β))) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithTop.{u2} β) (WithBot.{u2} (OrderDual.{u2} β))) (WithTop.toDual.{u2} β) (WithTop.map.{u1, u2} α β f a)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} (OrderDual.{u1} α) α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithTop.{u2} α), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} β) => WithBot.{u1} (OrderDual.{u1} β)) (WithTop.map.{u2, u1} α β f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} β) (WithBot.{u1} (OrderDual.{u1} β))) (WithTop.{u1} β) (fun (_x : WithTop.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} β) => WithBot.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} β) (WithBot.{u1} (OrderDual.{u1} β))) (WithTop.toDual.{u1} β) (WithTop.map.{u2, u1} α β f a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) β (OrderDual.{u1} β) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} β (OrderDual.{u1} β)) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => OrderDual.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β (OrderDual.{u1} β)) (OrderDual.toDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} (OrderDual.{u2} α) α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.{u2} α) (fun (_x : OrderDual.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u2} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.{u2} α) (fun (_x : WithTop.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u2} α) => WithBot.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.toDual.{u2} α) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithTop.{u2} α), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} β) => WithBot.{u1} (OrderDual.{u1} β)) (WithTop.map.{u2, u1} α β f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} β) (WithBot.{u1} (OrderDual.{u1} β))) (WithTop.{u1} β) (fun (_x : WithTop.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} β) => WithBot.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} β) (WithBot.{u1} (OrderDual.{u1} β))) (WithTop.toDual.{u1} β) (WithTop.map.{u2, u1} α β f a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) β (OrderDual.{u1} β) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} β (OrderDual.{u1} β)) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => OrderDual.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β (OrderDual.{u1} β)) (OrderDual.toDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} (OrderDual.{u2} α) α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.{u2} α) (fun (_x : OrderDual.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u2} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.{u2} α) (fun (_x : WithTop.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u2} α) => WithBot.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.toDual.{u2} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.to_dual_map WithTop.toDual_mapₓ'. -/
 theorem toDual_map (f : α → β) (a : WithTop α) :
     WithTop.toDual (map f a) = WithBot.map (toDual ∘ f ∘ ofDual) a.toDual :=
@@ -1116,7 +1116,7 @@ theorem toDual_map (f : α → β) (a : WithTop α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithTop.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithBot.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithBot.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithBot.{u2} β)) => (WithTop.{u2} (OrderDual.{u2} β)) -> (WithBot.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (WithBot.{u2} β)) (WithTop.ofDual.{u2} β) (WithTop.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f a)) (WithBot.map.{u1, u2} α β (Function.comp.{succ u1, succ u2, succ u2} α (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} α (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithTop.{u2} (OrderDual.{u2} α)), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} β)) => WithBot.{u1} β) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithBot.{u1} β)) (WithTop.{u1} (OrderDual.{u1} β)) (fun (_x : WithTop.{u1} (OrderDual.{u1} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} β)) => WithBot.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithBot.{u1} β)) (WithTop.ofDual.{u1} β) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} α (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.{u2} (OrderDual.{u2} α)) (fun (_x : WithTop.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u2} (OrderDual.{u2} α)) => WithBot.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.ofDual.{u2} α) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithTop.{u2} (OrderDual.{u2} α)), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} β)) => WithBot.{u1} β) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithBot.{u1} β)) (WithTop.{u1} (OrderDual.{u1} β)) (fun (_x : WithTop.{u1} (OrderDual.{u1} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} β)) => WithBot.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} β)) (WithBot.{u1} β)) (WithTop.ofDual.{u1} β) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} α (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.{u2} (OrderDual.{u2} α)) (fun (_x : WithTop.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u2} (OrderDual.{u2} α)) => WithBot.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.ofDual.{u2} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.of_dual_map WithTop.ofDual_mapₓ'. -/
 theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithTop αᵒᵈ) :
     WithTop.ofDual (map f a) = WithBot.map (ofDual ∘ f ∘ toDual) a.ofDual :=
@@ -1174,7 +1174,7 @@ theorem toDual_le_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.le_to_dual_iff WithTop.le_toDual_iffₓ'. -/
 theorem le_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     a ≤ WithTop.toDual b ↔ b ≤ WithBot.ofDual a :=
@@ -1199,7 +1199,7 @@ theorem ofDual_le_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.le_of_dual_iff WithTop.le_ofDual_iffₓ'. -/
 theorem le_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     a ≤ WithTop.ofDual b ↔ b ≤ WithBot.toDual a :=
@@ -1327,7 +1327,7 @@ instance (priority := 10) : LT (WithTop α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) b) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) a) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) b) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) a) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) b) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_top.to_dual_lt_iff WithTop.toDual_lt_iffₓ'. -/
 theorem toDual_lt_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
     WithTop.toDual a < b ↔ WithBot.ofDual b < a :=
@@ -1338,7 +1338,7 @@ theorem toDual_lt_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.lt_to_dual_iff WithTop.lt_toDual_iffₓ'. -/
 theorem lt_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     a < WithTop.toDual b ↔ b < WithBot.ofDual a :=
@@ -1349,7 +1349,7 @@ theorem lt_toDual_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) b a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) a) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) b a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) a) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) b a)
 Case conversion may be inaccurate. Consider using '#align with_top.to_dual_lt_to_dual_iff WithTop.toDual_lt_toDual_iffₓ'. -/
 @[simp]
 theorem toDual_lt_toDual_iff {a b : WithTop α} : WithTop.toDual a < WithTop.toDual b ↔ b < a :=
@@ -1360,7 +1360,7 @@ theorem toDual_lt_toDual_iff {a b : WithTop α} : WithTop.toDual a < WithTop.toD
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) b) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) a) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) b) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) a) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) b) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_top.of_dual_lt_iff WithTop.ofDual_lt_iffₓ'. -/
 theorem ofDual_lt_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
     WithTop.ofDual a < b ↔ WithBot.toDual b < a :=
@@ -1371,7 +1371,7 @@ theorem ofDual_lt_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_top.lt_of_dual_iff WithTop.lt_ofDual_iffₓ'. -/
 theorem lt_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     a < WithTop.ofDual b ↔ b < WithBot.toDual a :=
@@ -1382,7 +1382,7 @@ theorem lt_ofDual_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) a) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) a) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b)) (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b a)
 Case conversion may be inaccurate. Consider using '#align with_top.of_dual_lt_of_dual_iff WithTop.ofDual_lt_ofDual_iffₓ'. -/
 @[simp]
 theorem ofDual_lt_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a < WithTop.ofDual b ↔ b < a :=
@@ -1443,7 +1443,7 @@ theorem ofDual_apply_coe (a : αᵒᵈ) : WithBot.ofDual (a : WithBot αᵒᵈ)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithTop.{u1} α), Eq.{succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a)) (WithTop.map.{u1, u2} α (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} α β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) f) a)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithTop.{u2} α), Eq.{succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.{u2} α) (fun (_x : WithTop.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u2} α) => WithBot.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.toDual.{u2} α) a)) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} (OrderDual.{u1} β)) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} β) => OrderDual.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.toDual.{u1} (OrderDual.{u1} β))) f) a)
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithTop.{u2} α), Eq.{succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.{u2} α) (fun (_x : WithTop.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u2} α) => WithBot.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} α) (WithBot.{u2} (OrderDual.{u2} α))) (WithTop.toDual.{u2} α) a)) (WithTop.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} (OrderDual.{u1} β)) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => OrderDual.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) (OrderDual.{u1} (OrderDual.{u1} β))) (OrderDual.toDual.{u1} (OrderDual.{u1} β))) f) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.map_to_dual WithBot.map_toDualₓ'. -/
 theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithTop α) :
     WithBot.map f (WithTop.toDual a) = a.map (toDual ∘ f) :=
@@ -1454,7 +1454,7 @@ theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithTop α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithTop.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithBot.{u2} β) (WithBot.map.{u1, u2} α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a)) (WithTop.map.{u1, u2} (OrderDual.{u1} α) β (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) f) a)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithTop.{u2} (OrderDual.{u2} α)), Eq.{succ u1} (WithBot.{u1} β) (WithBot.map.{u2, u1} α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.{u2} (OrderDual.{u2} α)) (fun (_x : WithTop.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u2} (OrderDual.{u2} α)) => WithBot.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.ofDual.{u2} α) a)) (WithTop.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) f) a)
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithTop.{u2} (OrderDual.{u2} α)), Eq.{succ u1} (WithBot.{u1} β) (WithBot.map.{u2, u1} α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.{u2} (OrderDual.{u2} α)) (fun (_x : WithTop.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u2} (OrderDual.{u2} α)) => WithBot.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithTop.{u2} (OrderDual.{u2} α)) (WithBot.{u2} α)) (WithTop.ofDual.{u2} α) a)) (WithTop.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) f) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.map_of_dual WithBot.map_ofDualₓ'. -/
 theorem map_ofDual (f : α → β) (a : WithTop αᵒᵈ) :
     WithBot.map f (WithTop.ofDual a) = a.map (ofDual ∘ f) :=
@@ -1465,7 +1465,7 @@ theorem map_ofDual (f : α → β) (a : WithTop αᵒᵈ) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : α -> β) (a : WithBot.{u1} α), Eq.{succ u2} (WithTop.{u2} (OrderDual.{u2} β)) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} β) (WithTop.{u2} (OrderDual.{u2} β))) (fun (_x : Equiv.{succ u2, succ u2} (WithBot.{u2} β) (WithTop.{u2} (OrderDual.{u2} β))) => (WithBot.{u2} β) -> (WithTop.{u2} (OrderDual.{u2} β))) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithBot.{u2} β) (WithTop.{u2} (OrderDual.{u2} β))) (WithBot.toDual.{u2} β) (WithBot.map.{u1, u2} α β f a)) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) (Function.comp.{succ u1, succ u2, succ u2} (OrderDual.{u1} α) β (OrderDual.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} β (OrderDual.{u2} β)) => β -> (OrderDual.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} β (OrderDual.{u2} β)) (OrderDual.toDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} (OrderDual.{u1} α) α β f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithBot.{u2} α), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} β) => WithTop.{u1} (OrderDual.{u1} β)) (WithBot.map.{u2, u1} α β f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} β) (WithTop.{u1} (OrderDual.{u1} β))) (WithBot.{u1} β) (fun (_x : WithBot.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} β) => WithTop.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} β) (WithTop.{u1} (OrderDual.{u1} β))) (WithBot.toDual.{u1} β) (WithBot.map.{u2, u1} α β f a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) β (OrderDual.{u1} β) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} β (OrderDual.{u1} β)) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : β) => OrderDual.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β (OrderDual.{u1} β)) (OrderDual.toDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} (OrderDual.{u2} α) α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.{u2} α) (fun (_x : OrderDual.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u2} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.{u2} α) (fun (_x : WithBot.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u2} α) => WithTop.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.toDual.{u2} α) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : α -> β) (a : WithBot.{u2} α), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} β) => WithTop.{u1} (OrderDual.{u1} β)) (WithBot.map.{u2, u1} α β f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} β) (WithTop.{u1} (OrderDual.{u1} β))) (WithBot.{u1} β) (fun (_x : WithBot.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} β) => WithTop.{u1} (OrderDual.{u1} β)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} β) (WithTop.{u1} (OrderDual.{u1} β))) (WithBot.toDual.{u1} β) (WithBot.map.{u2, u1} α β f a)) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) (Function.comp.{succ u2, succ u1, succ u1} (OrderDual.{u2} α) β (OrderDual.{u1} β) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} β (OrderDual.{u1} β)) β (fun (_x : β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : β) => OrderDual.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} β (OrderDual.{u1} β)) (OrderDual.toDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} (OrderDual.{u2} α) α β f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.{u2} α) (fun (_x : OrderDual.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u2} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (OrderDual.{u2} α) α) (OrderDual.ofDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.{u2} α) (fun (_x : WithBot.{u2} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u2} α) => WithTop.{u2} (OrderDual.{u2} α)) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} α) (WithTop.{u2} (OrderDual.{u2} α))) (WithBot.toDual.{u2} α) a))
 Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_map WithBot.toDual_mapₓ'. -/
 theorem toDual_map (f : α → β) (a : WithBot α) :
     WithBot.toDual (WithBot.map f a) = map (toDual ∘ f ∘ ofDual) a.toDual :=
@@ -1476,7 +1476,7 @@ theorem toDual_map (f : α → β) (a : WithBot α) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} (f : (OrderDual.{u1} α) -> (OrderDual.{u2} β)) (a : WithBot.{u1} (OrderDual.{u1} α)), Eq.{succ u2} (WithTop.{u2} β) (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithTop.{u2} β)) (fun (_x : Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithTop.{u2} β)) => (WithBot.{u2} (OrderDual.{u2} β)) -> (WithTop.{u2} β)) (Equiv.hasCoeToFun.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} β)) (WithTop.{u2} β)) (WithBot.ofDual.{u2} β) (WithBot.map.{u1, u2} (OrderDual.{u1} α) (OrderDual.{u2} β) f a)) (WithBot.map.{u1, u2} α β (Function.comp.{succ u1, succ u2, succ u2} α (OrderDual.{u2} β) β (coeFn.{succ u2, succ u2} (Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) (fun (_x : Equiv.{succ u2, succ u2} (OrderDual.{u2} β) β) => (OrderDual.{u2} β) -> β) (Equiv.hasCoeToFun.{succ u2, succ u2} (OrderDual.{u2} β) β) (OrderDual.ofDual.{u2} β)) (Function.comp.{succ u1, succ u1, succ u2} α (OrderDual.{u1} α) (OrderDual.{u2} β) f (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α)))) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithBot.{u2} (OrderDual.{u2} α)), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} β)) => WithTop.{u1} β) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithTop.{u1} β)) (WithBot.{u1} (OrderDual.{u1} β)) (fun (_x : WithBot.{u1} (OrderDual.{u1} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} β)) => WithTop.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithTop.{u1} β)) (WithBot.ofDual.{u1} β) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} α (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.{u2} (OrderDual.{u2} α)) (fun (_x : WithBot.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u2} (OrderDual.{u2} α)) => WithTop.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.ofDual.{u2} α) a))
+  forall {α : Type.{u2}} {β : Type.{u1}} (f : (OrderDual.{u2} α) -> (OrderDual.{u1} β)) (a : WithBot.{u2} (OrderDual.{u2} α)), Eq.{succ u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} β)) => WithTop.{u1} β) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithTop.{u1} β)) (WithBot.{u1} (OrderDual.{u1} β)) (fun (_x : WithBot.{u1} (OrderDual.{u1} β)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} β)) => WithTop.{u1} β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} β)) (WithTop.{u1} β)) (WithBot.ofDual.{u1} β) (WithBot.map.{u2, u1} (OrderDual.{u2} α) (OrderDual.{u1} β) f a)) (WithBot.map.{u2, u1} α β (Function.comp.{succ u2, succ u1, succ u1} α (OrderDual.{u1} β) β (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.{u1} β) (fun (_x : OrderDual.{u1} β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} β) => β) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} β) β) (OrderDual.ofDual.{u1} β)) (Function.comp.{succ u2, succ u2, succ u1} α (OrderDual.{u2} α) (OrderDual.{u1} β) f (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} α (OrderDual.{u2} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} α (OrderDual.{u2} α)) (OrderDual.toDual.{u2} α)))) (FunLike.coe.{succ u2, succ u2, succ u2} (Equiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.{u2} (OrderDual.{u2} α)) (fun (_x : WithBot.{u2} (OrderDual.{u2} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u2} (OrderDual.{u2} α)) => WithTop.{u2} α) _x) (Equiv.instFunLikeEquiv.{succ u2, succ u2} (WithBot.{u2} (OrderDual.{u2} α)) (WithTop.{u2} α)) (WithBot.ofDual.{u2} α) a))
 Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_map WithBot.ofDual_mapₓ'. -/
 theorem ofDual_map (f : αᵒᵈ → βᵒᵈ) (a : WithBot αᵒᵈ) :
     WithBot.ofDual (WithBot.map f a) = map (ofDual ∘ f ∘ toDual) a.ofDual :=
@@ -1491,7 +1491,7 @@ variable [LE α] {a b : α}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) b) (WithBot.le.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) b) (WithBot.le.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_le_iff WithBot.toDual_le_iffₓ'. -/
 theorem toDual_le_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     WithBot.toDual a ≤ b ↔ WithTop.ofDual b ≤ a :=
@@ -1516,7 +1516,7 @@ theorem toDual_le_toDual_iff {a b : WithBot α} : WithBot.toDual a ≤ WithBot.t
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LE.le.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLe.{u1} (OrderDual.{u1} α) (OrderDual.hasLe.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.le.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) b) (WithBot.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.le.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LE.le.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) b) (WithBot.le.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_le_iff WithBot.ofDual_le_iffₓ'. -/
 theorem ofDual_le_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     WithBot.ofDual a ≤ b ↔ WithTop.toDual b ≤ a :=
@@ -1547,7 +1547,7 @@ variable [LT α] {a b : α}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) b) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithTop.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) b) (WithBot.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_lt_iff WithBot.toDual_lt_iffₓ'. -/
 theorem toDual_lt_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
     WithBot.toDual a < b ↔ WithTop.ofDual b < a :=
@@ -1558,7 +1558,7 @@ theorem toDual_lt_iff {a : WithBot α} {b : WithTop αᵒᵈ} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) => (WithTop.{u1} (OrderDual.{u1} α)) -> (WithBot.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.{u1} (OrderDual.{u1} α)) (fun (_x : WithTop.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} (OrderDual.{u1} α)) => WithBot.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithBot.{u1} α)) (WithTop.ofDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_bot.lt_to_dual_iff WithBot.lt_toDual_iffₓ'. -/
 theorem lt_toDual_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
     a < WithBot.toDual b ↔ b < WithTop.ofDual a :=
@@ -1569,7 +1569,7 @@ theorem lt_toDual_iff {a : WithTop αᵒᵈ} {b : WithBot α} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} (OrderDual.{u1} α)) (WithTop.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) => (WithBot.{u1} α) -> (WithTop.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) b a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) b a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} α} {b : WithBot.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) a) (WithTop.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.{u1} α) (fun (_x : WithBot.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} α) => WithTop.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} α) (WithTop.{u1} (OrderDual.{u1} α))) (WithBot.toDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) b a)
 Case conversion may be inaccurate. Consider using '#align with_bot.to_dual_lt_to_dual_iff WithBot.toDual_lt_toDual_iffₓ'. -/
 @[simp]
 theorem toDual_lt_toDual_iff {a b : WithBot α} : WithBot.toDual a < WithBot.toDual b ↔ b < a :=
@@ -1580,7 +1580,7 @@ theorem toDual_lt_toDual_iff {a b : WithBot α} : WithBot.toDual a < WithBot.toD
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) b) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithTop.{u1} α}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) b) (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) b) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) b) a)
 Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_lt_iff WithBot.ofDual_lt_iffₓ'. -/
 theorem ofDual_lt_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
     WithBot.ofDual a < b ↔ WithTop.toDual b < a :=
@@ -1591,7 +1591,7 @@ theorem ofDual_lt_iff {a : WithBot αᵒᵈ} {b : WithTop α} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) a (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (fun (_x : Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) => (WithTop.{u1} α) -> (WithBot.{u1} (OrderDual.{u1} α))) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithTop.{u1} α} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) a (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.{u1} α) (fun (_x : WithTop.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithTop.{u1} α) => WithBot.{u1} (OrderDual.{u1} α)) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithTop.{u1} α) (WithBot.{u1} (OrderDual.{u1} α))) (WithTop.toDual.{u1} α) a))
 Case conversion may be inaccurate. Consider using '#align with_bot.lt_of_dual_iff WithBot.lt_ofDual_iffₓ'. -/
 theorem lt_ofDual_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
     a < WithBot.ofDual b ↔ b < WithTop.toDual a :=
@@ -1602,7 +1602,7 @@ theorem lt_ofDual_iff {a : WithTop α} {b : WithBot αᵒᵈ} :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) => (WithBot.{u1} (OrderDual.{u1} α)) -> (WithTop.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.hasLt.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1)) b a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b a)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {a : WithBot.{u1} (OrderDual.{u1} α)} {b : WithBot.{u1} (OrderDual.{u1} α)}, Iff (LT.lt.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) a) (WithTop.lt.{u1} α _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.{u1} (OrderDual.{u1} α)) (fun (_x : WithBot.{u1} (OrderDual.{u1} α)) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : WithBot.{u1} (OrderDual.{u1} α)) => WithTop.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithTop.{u1} α)) (WithBot.ofDual.{u1} α) b)) (LT.lt.{u1} (WithBot.{u1} (OrderDual.{u1} α)) (WithBot.lt.{u1} (OrderDual.{u1} α) (OrderDual.instLTOrderDual.{u1} α _inst_1)) b a)
 Case conversion may be inaccurate. Consider using '#align with_bot.of_dual_lt_of_dual_iff WithBot.ofDual_lt_ofDual_iffₓ'. -/
 @[simp]
 theorem ofDual_lt_ofDual_iff {a b : WithBot αᵒᵈ} : WithBot.ofDual a < WithBot.ofDual b ↔ b < a :=
@@ -1894,7 +1894,7 @@ instance [DistribLattice α] : DistribLattice (WithTop α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10232 : α) (x._@.Mathlib.Order.WithBot._hyg.10234 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10232 x._@.Mathlib.Order.WithBot._hyg.10234)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10252 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10254 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10252 x._@.Mathlib.Order.WithBot._hyg.10254)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10328 : α) (x._@.Mathlib.Order.WithBot._hyg.10330 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10328 x._@.Mathlib.Order.WithBot._hyg.10330)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10348 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10350 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10348 x._@.Mathlib.Order.WithBot._hyg.10350)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_le WithTop.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithTop α) (· ≤ ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLE _ _) toDual_le_toDual_iff
@@ -1904,7 +1904,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10287 : α) (x._@.Mathlib.Order.WithBot._hyg.10289 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10287 x._@.Mathlib.Order.WithBot._hyg.10289)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10307 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10309 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10307 x._@.Mathlib.Order.WithBot._hyg.10309)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10383 : α) (x._@.Mathlib.Order.WithBot._hyg.10385 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10383 x._@.Mathlib.Order.WithBot._hyg.10385)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10403 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10405 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10403 x._@.Mathlib.Order.WithBot._hyg.10405)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_lt WithTop.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithTop α) (· < ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLT _ _) toDual_lt_toDual_iff
@@ -1914,7 +1914,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithT
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10342 : α) (x._@.Mathlib.Order.WithBot._hyg.10344 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10342 x._@.Mathlib.Order.WithBot._hyg.10344)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10362 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10364 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10362 x._@.Mathlib.Order.WithBot._hyg.10364)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10438 : α) (x._@.Mathlib.Order.WithBot._hyg.10440 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10438 x._@.Mathlib.Order.WithBot._hyg.10440)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10458 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10460 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10458 x._@.Mathlib.Order.WithBot._hyg.10460)
 Case conversion may be inaccurate. Consider using '#align with_top.is_total_le WithTop.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) :=
   ⟨fun _ _ => by

bump to nightly-2023-02-28-10

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

533b9a85

Diff

@@ -688,7 +688,7 @@ instance [DistribLattice α] : DistribLattice (WithBot α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4115 : α) (x._@.Mathlib.Order.WithBot._hyg.4117 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4115 x._@.Mathlib.Order.WithBot._hyg.4117)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4135 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4137 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4135 x._@.Mathlib.Order.WithBot._hyg.4137)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4170 : α) (x._@.Mathlib.Order.WithBot._hyg.4172 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4170 x._@.Mathlib.Order.WithBot._hyg.4172)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4190 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4192 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4190 x._@.Mathlib.Order.WithBot._hyg.4192)
 Case conversion may be inaccurate. Consider using '#align with_bot.decidable_le WithBot.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
   | none, x => isTrue fun a h => Option.noConfusion h
@@ -700,7 +700,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4277 : α) (x._@.Mathlib.Order.WithBot._hyg.4279 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4277 x._@.Mathlib.Order.WithBot._hyg.4279)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4297 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4299 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4297 x._@.Mathlib.Order.WithBot._hyg.4299)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4332 : α) (x._@.Mathlib.Order.WithBot._hyg.4334 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4332 x._@.Mathlib.Order.WithBot._hyg.4334)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4352 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4354 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4352 x._@.Mathlib.Order.WithBot._hyg.4354)
 Case conversion may be inaccurate. Consider using '#align with_bot.decidable_lt WithBot.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
   | none, some x => isTrue <| by exists x, rfl <;> rintro _ ⟨⟩
@@ -712,7 +712,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithB
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4476 : α) (x._@.Mathlib.Order.WithBot._hyg.4478 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4476 x._@.Mathlib.Order.WithBot._hyg.4478)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4496 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4498 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4496 x._@.Mathlib.Order.WithBot._hyg.4498)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4531 : α) (x._@.Mathlib.Order.WithBot._hyg.4533 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4531 x._@.Mathlib.Order.WithBot._hyg.4533)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4551 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4553 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4551 x._@.Mathlib.Order.WithBot._hyg.4553)
 Case conversion may be inaccurate. Consider using '#align with_bot.is_total_le WithBot.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithBot α) (· ≤ ·) :=
   ⟨fun a b =>
@@ -1894,7 +1894,7 @@ instance [DistribLattice α] : DistribLattice (WithTop α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10124 : α) (x._@.Mathlib.Order.WithBot._hyg.10126 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10124 x._@.Mathlib.Order.WithBot._hyg.10126)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10144 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10146 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10144 x._@.Mathlib.Order.WithBot._hyg.10146)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10232 : α) (x._@.Mathlib.Order.WithBot._hyg.10234 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10232 x._@.Mathlib.Order.WithBot._hyg.10234)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10252 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10254 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10252 x._@.Mathlib.Order.WithBot._hyg.10254)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_le WithTop.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithTop α) (· ≤ ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLE _ _) toDual_le_toDual_iff
@@ -1904,7 +1904,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10179 : α) (x._@.Mathlib.Order.WithBot._hyg.10181 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10179 x._@.Mathlib.Order.WithBot._hyg.10181)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10199 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10201 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10199 x._@.Mathlib.Order.WithBot._hyg.10201)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10287 : α) (x._@.Mathlib.Order.WithBot._hyg.10289 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10287 x._@.Mathlib.Order.WithBot._hyg.10289)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10307 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10309 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10307 x._@.Mathlib.Order.WithBot._hyg.10309)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_lt WithTop.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithTop α) (· < ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLT _ _) toDual_lt_toDual_iff
@@ -1914,7 +1914,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithT
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10234 : α) (x._@.Mathlib.Order.WithBot._hyg.10236 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10234 x._@.Mathlib.Order.WithBot._hyg.10236)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10254 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10256 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10254 x._@.Mathlib.Order.WithBot._hyg.10256)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10342 : α) (x._@.Mathlib.Order.WithBot._hyg.10344 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10342 x._@.Mathlib.Order.WithBot._hyg.10344)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10362 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10364 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10362 x._@.Mathlib.Order.WithBot._hyg.10364)
 Case conversion may be inaccurate. Consider using '#align with_top.is_total_le WithTop.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) :=
   ⟨fun _ _ => by

bump to nightly-2023-02-28-04

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

2097f8af

Diff

@@ -630,11 +630,15 @@ instance [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
         simp at h₂
         exact ⟨d, rfl, sup_le h₁' h₂⟩ }
 
-#print WithBot.coe_sup /-
+/- warning: with_bot.coe_sup -> WithBot.coe_sup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithBot.{u1} α) ((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} α))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b)) (Sup.sup.{u1} (WithBot.{u1} α) (SemilatticeSup.toHasSup.{u1} (WithBot.{u1} α) (WithBot.semilatticeSup.{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) ((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} α))) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b)) (Sup.sup.{u1} (WithBot.{u1} α) (SemilatticeSup.toSup.{u1} (WithBot.{u1} α) (WithBot.semilatticeSup.{u1} α _inst_1)) (WithBot.some.{u1} α a) (WithBot.some.{u1} α b))
+Case conversion may be inaccurate. Consider using '#align with_bot.coe_sup WithBot.coe_supₓ'. -/
 theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithBot α) = a ⊔ b :=
   rfl
 #align with_bot.coe_sup WithBot.coe_sup
--/
 
 instance [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
   { WithBot.orderBot,
@@ -654,11 +658,15 @@ instance [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
       rcases h₂ a rfl with ⟨c, ⟨⟩, ac⟩
       exact ⟨_, rfl, le_inf ab ac⟩ }
 
-#print WithBot.coe_inf /-
+/- warning: with_bot.coe_inf -> WithBot.coe_inf is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithBot.{u1} α) ((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} α))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b)) (Inf.inf.{u1} (WithBot.{u1} α) (SemilatticeInf.toHasInf.{u1} (WithBot.{u1} α) (WithBot.semilatticeInf.{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) ((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} α))) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b)) (Inf.inf.{u1} (WithBot.{u1} α) (SemilatticeInf.toInf.{u1} (WithBot.{u1} α) (WithBot.semilatticeInf.{u1} α _inst_1)) (WithBot.some.{u1} α a) (WithBot.some.{u1} α b))
+Case conversion may be inaccurate. Consider using '#align with_bot.coe_inf WithBot.coe_infₓ'. -/
 theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithBot α) = a ⊓ b :=
   rfl
 #align with_bot.coe_inf WithBot.coe_inf
--/
 
 instance [Lattice α] : Lattice (WithBot α) :=
   { WithBot.semilatticeSup, WithBot.semilatticeInf with }
@@ -1832,11 +1840,15 @@ instance [SemilatticeInf α] : SemilatticeInf (WithTop α) :=
         simp at h₂
         exact ⟨d, rfl, le_inf h₁' h₂⟩ }
 
-#print WithTop.coe_inf /-
+/- warning: with_top.coe_inf -> WithTop.coe_inf is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithTop.{u1} α) ((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} α))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α _inst_1) a b)) (Inf.inf.{u1} (WithTop.{u1} α) (SemilatticeInf.toHasInf.{u1} (WithTop.{u1} α) (WithTop.semilatticeInf.{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) ((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} α))) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Inf.inf.{u1} α (SemilatticeInf.toInf.{u1} α _inst_1) a b)) (Inf.inf.{u1} (WithTop.{u1} α) (SemilatticeInf.toInf.{u1} (WithTop.{u1} α) (WithTop.semilatticeInf.{u1} α _inst_1)) (WithTop.some.{u1} α a) (WithTop.some.{u1} α b))
+Case conversion may be inaccurate. Consider using '#align with_top.coe_inf WithTop.coe_infₓ'. -/
 theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithTop α) = a ⊓ b :=
   rfl
 #align with_top.coe_inf WithTop.coe_inf
--/
 
 instance [SemilatticeSup α] : SemilatticeSup (WithTop α) :=
   { WithTop.partialOrder with
@@ -1855,11 +1867,15 @@ instance [SemilatticeSup α] : SemilatticeSup (WithTop α) :=
       rcases h₂ a rfl with ⟨c, ⟨⟩, ac⟩
       exact ⟨_, rfl, sup_le ab ac⟩ }
 
-#print WithTop.coe_sup /-
+/- warning: with_top.coe_sup -> WithTop.coe_sup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithTop.{u1} α) ((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} α))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α _inst_1) a b)) (Sup.sup.{u1} (WithTop.{u1} α) (SemilatticeSup.toHasSup.{u1} (WithTop.{u1} α) (WithTop.semilatticeSup.{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) ((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} α))) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeSup.{u1} α] (a : α) (b : α), Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α _inst_1) a b)) (Sup.sup.{u1} (WithTop.{u1} α) (SemilatticeSup.toSup.{u1} (WithTop.{u1} α) (WithTop.semilatticeSup.{u1} α _inst_1)) (WithTop.some.{u1} α a) (WithTop.some.{u1} α b))
+Case conversion may be inaccurate. Consider using '#align with_top.coe_sup WithTop.coe_supₓ'. -/
 theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithTop α) = a ⊔ b :=
   rfl
 #align with_top.coe_sup WithTop.coe_sup
--/
 
 instance [Lattice α] : Lattice (WithTop α) :=
   { WithTop.semilatticeSup, WithTop.semilatticeInf with }

bump to nightly-2023-02-25-08

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

2eb4cae7

Diff

@@ -178,19 +178,25 @@ theorem coe_eq_coe : (a : WithBot α) = b ↔ a = b :=
 #align with_bot.coe_eq_coe WithBot.coe_eq_coe
 -/
 
+#print WithBot.unbot'_eq_iff /-
 theorem unbot'_eq_iff {d y : α} {x : WithBot α} : unbot' d x = y ↔ x = y ∨ x = ⊥ ∧ y = d := by
   induction x using WithBot.recBotCoe <;> simp [@eq_comm _ d, coe_eq_coe]
 #align with_bot.unbot'_eq_iff WithBot.unbot'_eq_iff
+-/
 
+#print WithBot.unbot'_eq_self_iff /-
 @[simp]
 theorem unbot'_eq_self_iff {d : α} {x : WithBot α} : unbot' d x = d ↔ x = d ∨ x = ⊥ := by
   simp [unbot'_eq_iff]
 #align with_bot.unbot'_eq_self_iff WithBot.unbot'_eq_self_iff
+-/
 
+#print WithBot.unbot'_eq_unbot'_iff /-
 theorem unbot'_eq_unbot'_iff {d : α} {x y : WithBot α} :
     unbot' d x = unbot' d y ↔ x = y ∨ x = d ∧ y = ⊥ ∨ x = ⊥ ∧ y = d := by
   induction y using WithBot.recBotCoe <;> simp [unbot'_eq_iff, or_comm', coe_eq_coe]
 #align with_bot.unbot'_eq_unbot'_iff WithBot.unbot'_eq_unbot'_iff
+-/
 
 #print WithBot.map /-
 /-- Lift a map `f : α → β` to `with_bot α → with_bot β`. Implemented using `option.map`. -/
@@ -448,6 +454,12 @@ theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a, x = ↑a → a < b
   | none => by simp [none_eq_bot, bot_lt_coe]
 #align with_bot.lt_coe_iff WithBot.lt_coe_iff
 
+/- warning: with_bot.bot_lt_iff_ne_bot -> WithBot.bot_lt_iff_ne_bot is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {x : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) x) (Ne.{succ u1} (WithBot.{u1} α) x (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {x : WithBot.{u1} α}, Iff (LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) x) (Ne.{succ u1} (WithBot.{u1} α) x (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))
+Case conversion may be inaccurate. Consider using '#align with_bot.bot_lt_iff_ne_bot WithBot.bot_lt_iff_ne_botₓ'. -/
 /-- A version of `bot_lt_iff_ne_bot` for `with_bot` that only requires `has_lt α`, not
 `partial_order α`. -/
 protected theorem bot_lt_iff_ne_bot : ∀ {x : WithBot α}, ⊥ < x ↔ x ≠ ⊥
@@ -668,7 +680,7 @@ instance [DistribLattice α] : DistribLattice (WithBot α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.3852 : α) (x._@.Mathlib.Order.WithBot._hyg.3854 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.3852 x._@.Mathlib.Order.WithBot._hyg.3854)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.3872 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.3874 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.3872 x._@.Mathlib.Order.WithBot._hyg.3874)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4115 : α) (x._@.Mathlib.Order.WithBot._hyg.4117 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4115 x._@.Mathlib.Order.WithBot._hyg.4117)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4135 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4137 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4135 x._@.Mathlib.Order.WithBot._hyg.4137)
 Case conversion may be inaccurate. Consider using '#align with_bot.decidable_le WithBot.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
   | none, x => isTrue fun a h => Option.noConfusion h
@@ -680,7 +692,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithBot.{u1} α) (LT.lt.{u1} (WithBot.{u1} α) (WithBot.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4014 : α) (x._@.Mathlib.Order.WithBot._hyg.4016 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4014 x._@.Mathlib.Order.WithBot._hyg.4016)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4034 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4036 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4034 x._@.Mathlib.Order.WithBot._hyg.4036)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4277 : α) (x._@.Mathlib.Order.WithBot._hyg.4279 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4277 x._@.Mathlib.Order.WithBot._hyg.4279)], DecidableRel.{succ u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4297 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4299 : WithBot.{u1} α) => LT.lt.{u1} (WithBot.{u1} α) (WithBot.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4297 x._@.Mathlib.Order.WithBot._hyg.4299)
 Case conversion may be inaccurate. Consider using '#align with_bot.decidable_lt WithBot.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
   | none, some x => isTrue <| by exists x, rfl <;> rintro _ ⟨⟩
@@ -692,7 +704,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithB
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithBot.{u1} α) (LE.le.{u1} (WithBot.{u1} α) (WithBot.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4213 : α) (x._@.Mathlib.Order.WithBot._hyg.4215 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4213 x._@.Mathlib.Order.WithBot._hyg.4215)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4233 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4235 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4233 x._@.Mathlib.Order.WithBot._hyg.4235)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.4476 : α) (x._@.Mathlib.Order.WithBot._hyg.4478 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.4476 x._@.Mathlib.Order.WithBot._hyg.4478)], IsTotal.{u1} (WithBot.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.4496 : WithBot.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.4498 : WithBot.{u1} α) => LE.le.{u1} (WithBot.{u1} α) (WithBot.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.4496 x._@.Mathlib.Order.WithBot._hyg.4498)
 Case conversion may be inaccurate. Consider using '#align with_bot.is_total_le WithBot.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithBot α) (· ≤ ·) :=
   ⟨fun a b =>
@@ -1008,19 +1020,25 @@ theorem coe_eq_coe : (a : WithTop α) = b ↔ a = b :=
 #align with_top.coe_eq_coe WithTop.coe_eq_coe
 -/
 
+#print WithTop.untop'_eq_iff /-
 theorem untop'_eq_iff {d y : α} {x : WithTop α} : untop' d x = y ↔ x = y ∨ x = ⊤ ∧ y = d :=
   WithBot.unbot'_eq_iff
 #align with_top.untop'_eq_iff WithTop.untop'_eq_iff
+-/
 
+#print WithTop.untop'_eq_self_iff /-
 @[simp]
 theorem untop'_eq_self_iff {d : α} {x : WithTop α} : untop' d x = d ↔ x = d ∨ x = ⊤ :=
   WithBot.unbot'_eq_self_iff
 #align with_top.untop'_eq_self_iff WithTop.untop'_eq_self_iff
+-/
 
+#print WithTop.untop'_eq_untop'_iff /-
 theorem untop'_eq_untop'_iff {d : α} {x y : WithTop α} :
     untop' d x = untop' d y ↔ x = y ∨ x = d ∧ y = ⊤ ∨ x = ⊤ ∧ y = d :=
   WithBot.unbot'_eq_unbot'_iff
 #align with_top.untop'_eq_untop'_iff WithTop.untop'_eq_untop'_iff
+-/
 
 #print WithTop.map /-
 /-- Lift a map `f : α → β` to `with_top α → with_top β`. Implemented using `option.map`. -/
@@ -1676,6 +1694,12 @@ theorem coe_lt_iff {x : WithTop α} : ↑a < x ↔ ∀ b, x = ↑b → a < b :=
   exact forall₂_congr fun _ _ => Iff.rfl
 #align with_top.coe_lt_iff WithTop.coe_lt_iff
 
+/- warning: with_top.lt_top_iff_ne_top -> WithTop.lt_top_iff_ne_top is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {x : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1) x (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) x (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] {x : WithTop.{u1} α}, Iff (LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) x (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))
+Case conversion may be inaccurate. Consider using '#align with_top.lt_top_iff_ne_top WithTop.lt_top_iff_ne_topₓ'. -/
 /-- A version of `lt_top_iff_ne_top` for `with_top` that only requires `has_lt α`, not
 `partial_order α`. -/
 protected theorem lt_top_iff_ne_top {x : WithTop α} : x < ⊤ ↔ x ≠ ⊤ :=
@@ -1854,7 +1878,7 @@ instance [DistribLattice α] : DistribLattice (WithTop α) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LE.le.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.9680 : α) (x._@.Mathlib.Order.WithBot._hyg.9682 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.9680 x._@.Mathlib.Order.WithBot._hyg.9682)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.9700 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.9702 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.9700 x._@.Mathlib.Order.WithBot._hyg.9702)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10124 : α) (x._@.Mathlib.Order.WithBot._hyg.10126 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10124 x._@.Mathlib.Order.WithBot._hyg.10126)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10144 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10146 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10144 x._@.Mathlib.Order.WithBot._hyg.10146)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_le WithTop.decidableLEₓ'. -/
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithTop α) (· ≤ ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLE _ _) toDual_le_toDual_iff
@@ -1864,7 +1888,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)], DecidableRel.{succ u1} (WithTop.{u1} α) (LT.lt.{u1} (WithTop.{u1} α) (WithTop.hasLt.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.9735 : α) (x._@.Mathlib.Order.WithBot._hyg.9737 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.9735 x._@.Mathlib.Order.WithBot._hyg.9737)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.9755 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.9757 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.9755 x._@.Mathlib.Order.WithBot._hyg.9757)
+  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10179 : α) (x._@.Mathlib.Order.WithBot._hyg.10181 : α) => LT.lt.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10179 x._@.Mathlib.Order.WithBot._hyg.10181)], DecidableRel.{succ u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10199 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10201 : WithTop.{u1} α) => LT.lt.{u1} (WithTop.{u1} α) (WithTop.lt.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10199 x._@.Mathlib.Order.WithBot._hyg.10201)
 Case conversion may be inaccurate. Consider using '#align with_top.decidable_lt WithTop.decidableLTₓ'. -/
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithTop α) (· < ·) :=
   fun _ _ => decidable_of_decidable_of_iff (WithBot.decidableLT _ _) toDual_lt_toDual_iff
@@ -1874,7 +1898,7 @@ instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithT
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α _inst_1)], IsTotal.{u1} (WithTop.{u1} α) (LE.le.{u1} (WithTop.{u1} α) (WithTop.hasLe.{u1} α _inst_1))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.9790 : α) (x._@.Mathlib.Order.WithBot._hyg.9792 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.9790 x._@.Mathlib.Order.WithBot._hyg.9792)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.9810 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.9812 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.9810 x._@.Mathlib.Order.WithBot._hyg.9812)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.WithBot._hyg.10234 : α) (x._@.Mathlib.Order.WithBot._hyg.10236 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.WithBot._hyg.10234 x._@.Mathlib.Order.WithBot._hyg.10236)], IsTotal.{u1} (WithTop.{u1} α) (fun (x._@.Mathlib.Order.WithBot._hyg.10254 : WithTop.{u1} α) (x._@.Mathlib.Order.WithBot._hyg.10256 : WithTop.{u1} α) => LE.le.{u1} (WithTop.{u1} α) (WithTop.le.{u1} α _inst_1) x._@.Mathlib.Order.WithBot._hyg.10254 x._@.Mathlib.Order.WithBot._hyg.10256)
 Case conversion may be inaccurate. Consider using '#align with_top.is_total_le WithTop.isTotal_leₓ'. -/
 instance isTotal_le [LE α] [IsTotal α (· ≤ ·)] : IsTotal (WithTop α) (· ≤ ·) :=
   ⟨fun _ _ => by

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: Johannes Hölzl
 
 ! This file was ported from Lean 3 source module order.with_bot
-! leanprover-community/mathlib commit 995b47e555f1b6297c7cf16855f1023e355219fb
+! leanprover-community/mathlib commit afdb4fa3b32d41106a4a09b371ce549ad7958abd
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -178,6 +178,20 @@ theorem coe_eq_coe : (a : WithBot α) = b ↔ a = b :=
 #align with_bot.coe_eq_coe WithBot.coe_eq_coe
 -/
 
+theorem unbot'_eq_iff {d y : α} {x : WithBot α} : unbot' d x = y ↔ x = y ∨ x = ⊥ ∧ y = d := by
+  induction x using WithBot.recBotCoe <;> simp [@eq_comm _ d, coe_eq_coe]
+#align with_bot.unbot'_eq_iff WithBot.unbot'_eq_iff
+
+@[simp]
+theorem unbot'_eq_self_iff {d : α} {x : WithBot α} : unbot' d x = d ↔ x = d ∨ x = ⊥ := by
+  simp [unbot'_eq_iff]
+#align with_bot.unbot'_eq_self_iff WithBot.unbot'_eq_self_iff
+
+theorem unbot'_eq_unbot'_iff {d : α} {x y : WithBot α} :
+    unbot' d x = unbot' d y ↔ x = y ∨ x = d ∧ y = ⊥ ∨ x = ⊥ ∧ y = d := by
+  induction y using WithBot.recBotCoe <;> simp [unbot'_eq_iff, or_comm', coe_eq_coe]
+#align with_bot.unbot'_eq_unbot'_iff WithBot.unbot'_eq_unbot'_iff
+
 #print WithBot.map /-
 /-- Lift a map `f : α → β` to `with_bot α → with_bot β`. Implemented using `option.map`. -/
 def map (f : α → β) : WithBot α → WithBot β :=
@@ -434,6 +448,13 @@ theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a, x = ↑a → a < b
   | none => by simp [none_eq_bot, bot_lt_coe]
 #align with_bot.lt_coe_iff WithBot.lt_coe_iff
 
+/-- A version of `bot_lt_iff_ne_bot` for `with_bot` that only requires `has_lt α`, not
+`partial_order α`. -/
+protected theorem bot_lt_iff_ne_bot : ∀ {x : WithBot α}, ⊥ < x ↔ x ≠ ⊥
+  | ⊥ => iff_of_false (WithBot.not_lt_none _) fun h => h rfl
+  | (x : α) => by simp [bot_lt_coe]
+#align with_bot.bot_lt_iff_ne_bot WithBot.bot_lt_iff_ne_bot
+
 end LT
 
 instance [Preorder α] : Preorder (WithBot α)
@@ -987,6 +1008,20 @@ theorem coe_eq_coe : (a : WithTop α) = b ↔ a = b :=
 #align with_top.coe_eq_coe WithTop.coe_eq_coe
 -/
 
+theorem untop'_eq_iff {d y : α} {x : WithTop α} : untop' d x = y ↔ x = y ∨ x = ⊤ ∧ y = d :=
+  WithBot.unbot'_eq_iff
+#align with_top.untop'_eq_iff WithTop.untop'_eq_iff
+
+@[simp]
+theorem untop'_eq_self_iff {d : α} {x : WithTop α} : untop' d x = d ↔ x = d ∨ x = ⊤ :=
+  WithBot.unbot'_eq_self_iff
+#align with_top.untop'_eq_self_iff WithTop.untop'_eq_self_iff
+
+theorem untop'_eq_untop'_iff {d : α} {x y : WithTop α} :
+    untop' d x = untop' d y ↔ x = y ∨ x = d ∧ y = ⊤ ∨ x = ⊤ ∧ y = d :=
+  WithBot.unbot'_eq_unbot'_iff
+#align with_top.untop'_eq_untop'_iff WithTop.untop'_eq_untop'_iff
+
 #print WithTop.map /-
 /-- Lift a map `f : α → β` to `with_top α → with_top β`. Implemented using `option.map`. -/
 def map (f : α → β) : WithTop α → WithTop β :=
@@ -1641,6 +1676,12 @@ theorem coe_lt_iff {x : WithTop α} : ↑a < x ↔ ∀ b, x = ↑b → a < b :=
   exact forall₂_congr fun _ _ => Iff.rfl
 #align with_top.coe_lt_iff WithTop.coe_lt_iff
 
+/-- A version of `lt_top_iff_ne_top` for `with_top` that only requires `has_lt α`, not
+`partial_order α`. -/
+protected theorem lt_top_iff_ne_top {x : WithTop α} : x < ⊤ ↔ x ≠ ⊤ :=
+  @WithBot.bot_lt_iff_ne_bot αᵒᵈ _ x
+#align with_top.lt_top_iff_ne_top WithTop.lt_top_iff_ne_top
+
 end LT
 
 instance [Preorder α] : Preorder (WithTop α)

995b47e5

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 (#12116)

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

596d5eca

Diff

@@ -525,7 +525,7 @@ theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = ma
 
 instance instWellFoundedLT [LT α] [WellFoundedLT α] : WellFoundedLT (WithBot α) where
   wf :=
-  have not_lt_bot : ∀ a : WithBot α, ¬ a < ⊥ := (nofun)
+  have not_lt_bot : ∀ a : WithBot α, ¬ a < ⊥ := nofun
   have acc_bot := ⟨_, by simp [not_lt_bot]⟩
   .intro fun
     | ⊥ => acc_bot

chore: replace λ by fun (#11301)

Per the style guidelines, λ is disallowed in mathlib. This is close to exhaustive; I left some tactic code alone when it seemed to me that tactic could be upstreamed soon.

Notes

In lines I was modifying anyway, I also converted => to ↦.
Also contains some mild in-passing indentation fixes in Mathlib/Order/SupClosed.
Some doc comments still contained Lean 3 syntax λ x, , which I also replaced.

af0f54a9

Diff

@@ -376,8 +376,8 @@ theorem coe_mono : Monotone (fun (a : α) => (a : WithBot α)) := fun _ _ => coe
 #align with_bot.coe_mono WithBot.coe_mono
 
 theorem monotone_iff {f : WithBot α → β} :
-    Monotone f ↔ Monotone (λ a => f a : α → β) ∧ ∀ x : α, f ⊥ ≤ f x :=
-  ⟨fun h => ⟨h.comp WithBot.coe_mono, fun _ => h bot_le⟩, fun h =>
+    Monotone f ↔ Monotone (fun a ↦ f a : α → β) ∧ ∀ x : α, f ⊥ ≤ f x :=
+  ⟨fun h ↦ ⟨h.comp WithBot.coe_mono, fun _ ↦ h bot_le⟩, fun h ↦
     WithBot.forall.2
       ⟨WithBot.forall.2 ⟨fun _ => le_rfl, fun x _ => h.2 x⟩, fun _ =>
         WithBot.forall.2 ⟨fun h => (not_coe_le_bot _ h).elim,
@@ -401,7 +401,7 @@ theorem strictMono_iff {f : WithBot α → β} :
 #align with_bot.strict_mono_iff WithBot.strictMono_iff
 
 theorem strictAnti_iff {f : WithBot α → β} :
-    StrictAnti f ↔ StrictAnti (λ a => f a : α → β) ∧ ∀ x : α, f x < f ⊥ :=
+    StrictAnti f ↔ StrictAnti (fun a ↦ f a : α → β) ∧ ∀ x : α, f x < f ⊥ :=
   strictMono_iff (β := βᵒᵈ)
 
 @[simp]
@@ -1223,7 +1223,7 @@ theorem strictMono_iff {f : WithTop α → β} :
 #align with_top.strict_mono_iff WithTop.strictMono_iff
 
 theorem strictAnti_iff {f : WithTop α → β} :
-    StrictAnti f ↔ StrictAnti (λ a => f a : α → β) ∧ ∀ x : α, f ⊤ < f x :=
+    StrictAnti f ↔ StrictAnti (fun a ↦ f a : α → β) ∧ ∀ x : α, f ⊤ < f x :=
   strictMono_iff (β := βᵒᵈ)
 
 @[simp]

chore: squeeze some non-terminal simps (#11247)

This PR accompanies #11246, squeezing some non-terminal simps highlighted by the linter until I decided to stop!

1ad8c3fe

Diff

@@ -442,7 +442,7 @@ instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
       · exact h₂ a rfl
       · exact h₁ a rfl
       · rcases h₁ b rfl with ⟨d, ⟨⟩, h₁'⟩
-        simp at h₂
+        simp only [some_le_some] at h₂
         exact ⟨d, rfl, sup_le h₁' h₂⟩ }
 
 theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithBot α) = (a : WithBot α) ⊔ b :=

chore: move Mathlib to v4.7.0-rc1 (#11162)

This is a very large PR, but it has been reviewed piecemeal already in PRs to the bump/v4.7.0 branch as we update to intermediate nightlies.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: damiano <adomani@gmail.com>

fa48894a

Diff

@@ -86,12 +86,12 @@ theorem some_eq_coe (a : α) : (Option.some a : WithBot α) = (↑a : WithBot α
 
 @[simp]
 theorem bot_ne_coe : ⊥ ≠ (a : WithBot α) :=
-  fun.
+  nofun
 #align with_bot.bot_ne_coe WithBot.bot_ne_coe
 
 @[simp]
 theorem coe_ne_bot : (a : WithBot α) ≠ ⊥ :=
-  fun.
+  nofun
 #align with_bot.coe_ne_bot WithBot.coe_ne_bot
 
 /-- Recursor for `WithBot` using the preferred forms `⊥` and `↑a`. -/
@@ -328,7 +328,7 @@ theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a : α, x = a → a < b
 /-- A version of `bot_lt_iff_ne_bot` for `WithBot` that only requires `LT α`, not
 `PartialOrder α`. -/
 protected theorem bot_lt_iff_ne_bot : ∀ {x : WithBot α}, ⊥ < x ↔ x ≠ ⊥
-  | ⊥ => by simpa using not_lt_none ⊥
+  | ⊥ => iff_of_false (not_lt_none _) <| by simp
   | (x : α) => by simp [bot_lt_coe]
 #align with_bot.bot_lt_iff_ne_bot WithBot.bot_lt_iff_ne_bot
 
@@ -525,7 +525,7 @@ theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = ma
 
 instance instWellFoundedLT [LT α] [WellFoundedLT α] : WellFoundedLT (WithBot α) where
   wf :=
-  have not_lt_bot : ∀ a : WithBot α, ¬ a < ⊥ := (fun.)
+  have not_lt_bot : ∀ a : WithBot α, ¬ a < ⊥ := (nofun)
   have acc_bot := ⟨_, by simp [not_lt_bot]⟩
   .intro fun
     | ⊥ => acc_bot
@@ -651,12 +651,12 @@ theorem some_eq_coe (a : α) : (Option.some a : WithTop α) = (↑a : WithTop α
 
 @[simp]
 theorem top_ne_coe : ⊤ ≠ (a : WithTop α) :=
-  fun.
+  nofun
 #align with_top.top_ne_coe WithTop.top_ne_coe
 
 @[simp]
 theorem coe_ne_top : (a : WithTop α) ≠ ⊤ :=
-  fun.
+  nofun
 #align with_top.coe_ne_top WithTop.coe_ne_top
 
 /-- Recursor for `WithTop` using the preferred forms `⊤` and `↑a`. -/

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

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

8be0b69c

Diff

@@ -754,7 +754,7 @@ theorem untop'_coe {α} (d x : α) : untop' d x = x :=
   rfl
 #align with_top.untop'_coe WithTop.untop'_coe
 
-@[simp, norm_cast] -- porting note: added `simp`
+@[simp, norm_cast] -- Porting note: added `simp`
 theorem coe_eq_coe : (a : WithTop α) = b ↔ a = b :=
   Option.some_inj
 #align with_top.coe_eq_coe WithTop.coe_eq_coe

chore: cleanup DecidableEq instances for WithTop/Bot (#11010)

Avoid relying on the autogenerated name, and remove duplicate instances.

64f31cfd

Diff

@@ -484,8 +484,8 @@ instance distribLattice [DistribLattice α] : DistribLattice (WithBot α) :=
       | (a₁ : α), (a₂ : α), ⊥ => inf_le_right
       | (a₁ : α), (a₂ : α), (a₃ : α) => coe_le_coe.mpr le_sup_inf }
 
--- porting note: added, previously this was found via unfolding `WithBot`
-instance decidableEq [DecidableEq α] : DecidableEq (WithBot α) := instDecidableEqOption
+instance decidableEq [DecidableEq α] : DecidableEq (WithBot α) :=
+  inferInstanceAs <| DecidableEq (Option α)
 
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
   | none, x => isTrue fun a h => Option.noConfusion h
@@ -1279,8 +1279,8 @@ instance distribLattice [DistribLattice α] : DistribLattice (WithTop α) :=
   { WithTop.lattice with
     le_sup_inf := @le_sup_inf (WithBot αᵒᵈ)ᵒᵈ _ }
 
--- porting note: added, previously this was found via unfolding `WithTop`
-instance decidableEq [DecidableEq α] : DecidableEq (WithTop α) := instDecidableEqOption
+instance decidableEq [DecidableEq α] : DecidableEq (WithTop α) :=
+  inferInstanceAs <| DecidableEq (Option α)
 
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] :
     @DecidableRel (WithTop α) (· ≤ ·) := fun _ _ =>

chore: tidy various files (#10362)

1c8a8a8e

Diff

@@ -1185,7 +1185,7 @@ instance preorder [Preorder α] : Preorder (WithTop α) where
   le_trans := @le_trans (WithBot αᵒᵈ)ᵒᵈ _
 
 instance partialOrder [PartialOrder α] : PartialOrder (WithTop α) where
-  le_antisymm := @le_antisymm  (WithBot αᵒᵈ)ᵒᵈ _
+  le_antisymm := @le_antisymm (WithBot αᵒᵈ)ᵒᵈ _
 #align with_top.partial_order WithTop.partialOrder
 
 section Preorder

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

@@ -166,21 +166,31 @@ theorem map_comm {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂
   Option.map_comm h _
 #align with_bot.map_comm WithBot.map_comm
 
+/-- The image of a binary function `f : α → β → γ` as a function
+`WithBot α → WithBot β → WithBot γ`.
+
+Mathematically this should be thought of as the image of the corresponding function `α × β → γ`. -/
+def map₂ : (α → β → γ) → WithBot α → WithBot β → WithBot γ := Option.map₂
+
+lemma map₂_coe_coe (f : α → β → γ) (a : α) (b : β) : map₂ f a b = f a b := rfl
+@[simp] lemma map₂_bot_left (f : α → β → γ) (b) : map₂ f ⊥ b = ⊥ := rfl
+@[simp] lemma map₂_bot_right (f : α → β → γ) (a) : map₂ f a ⊥ = ⊥ := by cases a <;> rfl
+@[simp] lemma map₂_coe_left (f : α → β → γ) (a : α) (b) : map₂ f a b = b.map fun b ↦ f a b := rfl
+@[simp] lemma map₂_coe_right (f : α → β → γ) (a) (b : β) : map₂ f a b = a.map (f · b) := by
+  cases a <;> rfl
+
+@[simp] lemma map₂_eq_bot_iff {f : α → β → γ} {a : WithBot α} {b : WithBot β} :
+    map₂ f a b = ⊥ ↔ a = ⊥ ∨ b = ⊥ := Option.map₂_eq_none_iff
+
 theorem ne_bot_iff_exists {x : WithBot α} : x ≠ ⊥ ↔ ∃ a : α, ↑a = x :=
   Option.ne_none_iff_exists
 #align with_bot.ne_bot_iff_exists WithBot.ne_bot_iff_exists
 
 /-- Deconstruct a `x : WithBot α` to the underlying value in `α`, given a proof that `x ≠ ⊥`. -/
-def unbot : ∀ x : WithBot α, x ≠ ⊥ → α
-  | ⊥, h => absurd rfl h
-  | Option.some x, _ => x
+def unbot : ∀ x : WithBot α, x ≠ ⊥ → α | (x : α), _ => x
 #align with_bot.unbot WithBot.unbot
 
-@[simp]
-theorem coe_unbot (x : WithBot α) (h : x ≠ ⊥) : (x.unbot h : WithBot α) = x := by
-  cases x
-  exact (h rfl).elim
-  rfl
+@[simp] lemma coe_unbot : ∀ (x : WithBot α) hx, x.unbot hx = x | (x : α), _ => rfl
 #align with_bot.coe_unbot WithBot.coe_unbot
 
 @[simp]
@@ -782,6 +792,22 @@ theorem map_comm {f₁ : α → β} {f₂ : α → γ} {g₁ : β → δ} {g₂
   Option.map_comm h _
 #align with_top.map_comm WithTop.map_comm
 
+/-- The image of a binary function `f : α → β → γ` as a function
+`WithTop α → WithTop β → WithTop γ`.
+
+Mathematically this should be thought of as the image of the corresponding function `α × β → γ`. -/
+def map₂ : (α → β → γ) → WithTop α → WithTop β → WithTop γ := Option.map₂
+
+lemma map₂_coe_coe (f : α → β → γ) (a : α) (b : β) : map₂ f a b = f a b := rfl
+@[simp] lemma map₂_top_left (f : α → β → γ) (b) : map₂ f ⊤ b = ⊤ := rfl
+@[simp] lemma map₂_top_right (f : α → β → γ) (a) : map₂ f a ⊤ = ⊤ := by cases a <;> rfl
+@[simp] lemma map₂_coe_left (f : α → β → γ) (a : α) (b) : map₂ f a b = b.map fun b ↦ f a b := rfl
+@[simp] lemma map₂_coe_right (f : α → β → γ) (a) (b : β) : map₂ f a b = a.map (f · b) := by
+  cases a <;> rfl
+
+@[simp] lemma map₂_eq_top_iff {f : α → β → γ} {a : WithTop α} {b : WithTop β} :
+    map₂ f a b = ⊤ ↔ a = ⊤ ∨ b = ⊤ := Option.map₂_eq_none_iff
+
 theorem map_toDual (f : αᵒᵈ → βᵒᵈ) (a : WithBot α) :
     map f (WithBot.toDual a) = a.map (toDual ∘ f) :=
   rfl
@@ -806,13 +832,10 @@ theorem ne_top_iff_exists {x : WithTop α} : x ≠ ⊤ ↔ ∃ a : α, ↑a = x
 #align with_top.ne_top_iff_exists WithTop.ne_top_iff_exists
 
 /-- Deconstruct a `x : WithTop α` to the underlying value in `α`, given a proof that `x ≠ ⊤`. -/
-def untop : ∀ x : WithTop α, x ≠ ⊤ → α :=
-  WithBot.unbot
+def untop : ∀ x : WithTop α, x ≠ ⊤ → α | (x : α), _ => x
 #align with_top.untop WithTop.untop
 
-@[simp]
-theorem coe_untop (x : WithTop α) (h : x ≠ ⊤) : (x.untop h : WithTop α) = x :=
-  WithBot.coe_unbot x h
+@[simp] lemma coe_untop : ∀ (x : WithTop α) hx, x.untop hx = x | (x : α), _ => rfl
 #align with_top.coe_untop WithTop.coe_untop
 
 @[simp]

feat: add lake exe shake to CI (#9751)

depends on: #9830
depends on: #9772
depends on: #9996

This checks files for unused imports. The output here is piped through gh-problem-matcher-wrap so that it will show up as annotations.

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

056cc4b2

Diff

@@ -3,6 +3,7 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
 -/
+import Mathlib.Init.Algebra.Classes
 import Mathlib.Logic.Nontrivial.Basic
 import Mathlib.Order.BoundedOrder
 import Mathlib.Data.Option.NAry

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

Also reuse proofs here and there.

9cc09f63

Diff

@@ -96,8 +96,8 @@ theorem coe_ne_bot : (a : WithBot α) ≠ ⊥ :=
 /-- Recursor for `WithBot` using the preferred forms `⊥` and `↑a`. -/
 @[elab_as_elim]
 def recBotCoe {C : WithBot α → Sort*} (bot : C ⊥) (coe : ∀ a : α, C a) : ∀ n : WithBot α, C n
-  | none => bot
-  | Option.some a => coe a
+  | ⊥ => bot
+  | (a : α) => coe a
 #align with_bot.rec_bot_coe WithBot.recBotCoe
 
 @[simp]
@@ -239,18 +239,18 @@ theorem coe_le : ∀ {o : Option α}, b ∈ o → ((a : WithBot α) ≤ o ↔ a
 #align with_bot.coe_le WithBot.coe_le
 
 theorem coe_le_iff : ∀ {x : WithBot α}, (a : WithBot α) ≤ x ↔ ∃ b : α, x = b ∧ a ≤ b
-  | Option.some x => by simp [some_eq_coe]
-  | none => iff_of_false (not_coe_le_bot _) <| by simp [none_eq_bot]
+  | (x : α) => by simp
+  | ⊥ => iff_of_false (not_coe_le_bot _) <| by simp
 #align with_bot.coe_le_iff WithBot.coe_le_iff
 
 theorem le_coe_iff : ∀ {x : WithBot α}, x ≤ b ↔ ∀ a : α, x = ↑a → a ≤ b
-  | Option.some b => by simp [some_eq_coe, coe_eq_coe]
-  | none => by simp [none_eq_bot]
+  | (b : α) => by simp
+  | ⊥ => by simp
 #align with_bot.le_coe_iff WithBot.le_coe_iff
 
 protected theorem _root_.IsMax.withBot (h : IsMax a) : IsMax (a : WithBot α)
-  | none, _ => bot_le
-  | Option.some _, hb => some_le_some.2 <| h <| some_le_some.1 hb
+  | ⊥, _ => bot_le
+  | (_ : α), hb => some_le_some.2 <| h <| some_le_some.1 hb
 #align is_max.with_bot IsMax.withBot
 
 theorem le_unbot_iff {a : α} {b : WithBot α} (h : b ≠ ⊥) :
@@ -305,13 +305,13 @@ theorem not_lt_none (a : WithBot α) : ¬@LT.lt (WithBot α) _ a none :=
 #align with_bot.not_lt_none WithBot.not_lt_none
 
 theorem lt_iff_exists_coe : ∀ {a b : WithBot α}, a < b ↔ ∃ p : α, b = p ∧ a < p
-  | a, Option.some b => by simp [some_eq_coe, coe_eq_coe]
-  | a, none => iff_of_false (not_lt_none _) <| by simp [none_eq_bot]
+  | a, some b => by simp [coe_eq_coe]
+  | a, ⊥ => iff_of_false (not_lt_none _) <| by simp
 #align with_bot.lt_iff_exists_coe WithBot.lt_iff_exists_coe
 
-theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a : α, x = ↑a → a < b
-  | Option.some b => by simp [some_eq_coe, coe_eq_coe, coe_lt_coe]
-  | none => by simp [none_eq_bot, bot_lt_coe]
+theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a : α, x = a → a < b
+  | (_ : α) => by simp
+  | ⊥ => by simp [bot_lt_coe]
 #align with_bot.lt_coe_iff WithBot.lt_coe_iff
 
 /-- A version of `bot_lt_iff_ne_bot` for `WithBot` that only requires `LT α`, not
@@ -1300,12 +1300,11 @@ instance instWellFoundedGT [LT α] [WellFoundedGT α] : WellFoundedGT (WithTop 
 
 instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithTop α) (· < ·) :=
-  ⟨by
-    rintro (a | a) (b | b)
-    · simp
-    · simp
-    · simp
-    · simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (· < ·) _ a b⟩
+  ⟨fun
+    | (a : α), (b : α) => by simp [trichotomous]
+    | ⊤, (b : α) => by simp
+    | (a : α), ⊤ => by simp
+    | ⊤, ⊤ => by simp⟩
 #align with_top.trichotomous.lt WithTop.trichotomous.lt
 
 instance IsWellOrder.lt [Preorder α] [IsWellOrder α (· < ·)] : IsWellOrder (WithTop α) (· < ·) where
@@ -1313,12 +1312,7 @@ instance IsWellOrder.lt [Preorder α] [IsWellOrder α (· < ·)] : IsWellOrder (
 
 instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     IsTrichotomous (WithTop α) (· > ·) :=
-  ⟨by
-    rintro (a | a) (b | b)
-    · simp
-    · simp
-    · simp
-    · simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (· > ·) _ a b⟩
+  have : IsTrichotomous α (· < ·) := .swap _; .swap _
 #align with_top.trichotomous.gt WithTop.trichotomous.gt
 
 instance IsWellOrder.gt [Preorder α] [IsWellOrder α (· > ·)] : IsWellOrder (WithTop α) (· > ·) where

feat(Order/WithBot): add WithBot.lt_coe_bot (#9898)

Add WithBot.lt_coe_bot and WithTop.coe_top_lt.
Use them to golf Nat.WithBot.lt_zero_iff, make n argument implicit.
Add section Preorder for WithBot and WithTop.
Move some lemmas to appropriate sections.
Add simp to WithBot.bot_lt_coe and WithTop.coe_lt_top.
Use the OrderDual trick to golf some proofs.

2475f305

Diff

@@ -263,6 +263,13 @@ theorem unbot_le_iff {a : WithBot α} (h : a ≠ ⊥) {b : α} :
   match a, h with
   | some _, _ => simp only [unbot_coe, coe_le_coe]
 
+theorem unbot'_le_iff {a : WithBot α} {b c : α} (h : a = ⊥ → b ≤ c) :
+    a.unbot' b ≤ c ↔ a ≤ c := by
+  induction a using recBotCoe
+  · simpa using h rfl
+  · simp
+#align with_bot.unbot'_bot_le_iff WithBot.unbot'_le_iff
+
 end LE
 
 section LT
@@ -287,6 +294,7 @@ theorem none_lt_some (a : α) : @LT.lt (WithBot α) _ none (some a) :=
   ⟨a, rfl, fun _ hb => (Option.not_mem_none _ hb).elim⟩
 #align with_bot.none_lt_some WithBot.none_lt_some
 
+@[simp]
 theorem bot_lt_coe (a : α) : (⊥ : WithBot α) < a :=
   none_lt_some a
 #align with_bot.bot_lt_coe WithBot.bot_lt_coe
@@ -313,6 +321,12 @@ protected theorem bot_lt_iff_ne_bot : ∀ {x : WithBot α}, ⊥ < x ↔ x ≠ 
   | (x : α) => by simp [bot_lt_coe]
 #align with_bot.bot_lt_iff_ne_bot WithBot.bot_lt_iff_ne_bot
 
+theorem unbot'_lt_iff {a : WithBot α} {b c : α} (h : a = ⊥ → b < c) :
+    a.unbot' b < c ↔ a < c := by
+  induction a using recBotCoe
+  · simpa [bot_lt_coe] using h rfl
+  · simp
+
 end LT
 
 instance preorder [Preorder α] : Preorder (WithBot α) where
@@ -333,24 +347,24 @@ instance partialOrder [PartialOrder α] : PartialOrder (WithBot α) :=
       cases' o₁ with a
       · cases' o₂ with b
         · rfl
-
         rcases h₂ b rfl with ⟨_, ⟨⟩, _⟩
-
       · rcases h₁ a rfl with ⟨b, ⟨⟩, h₁'⟩
         rcases h₂ b rfl with ⟨_, ⟨⟩, h₂'⟩
         rw [le_antisymm h₁' h₂']
          }
 #align with_bot.partial_order WithBot.partialOrder
 
-theorem coe_strictMono [Preorder α] : StrictMono (fun (a : α) => (a : WithBot α)) :=
-  fun _ _ => coe_lt_coe.2
+section Preorder
+
+variable [Preorder α] [Preorder β]
+
+theorem coe_strictMono : StrictMono (fun (a : α) => (a : WithBot α)) := fun _ _ => coe_lt_coe.2
 #align with_bot.coe_strict_mono WithBot.coe_strictMono
 
-theorem coe_mono [Preorder α] : Monotone (fun (a : α) => (a : WithBot α)) :=
-  fun _ _ => coe_le_coe.2
+theorem coe_mono : Monotone (fun (a : α) => (a : WithBot α)) := fun _ _ => coe_le_coe.2
 #align with_bot.coe_mono WithBot.coe_mono
 
-theorem monotone_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
+theorem monotone_iff {f : WithBot α → β} :
     Monotone f ↔ Monotone (λ a => f a : α → β) ∧ ∀ x : α, f ⊥ ≤ f x :=
   ⟨fun h => ⟨h.comp WithBot.coe_mono, fun _ => h bot_le⟩, fun h =>
     WithBot.forall.2
@@ -360,28 +374,27 @@ theorem monotone_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
 #align with_bot.monotone_iff WithBot.monotone_iff
 
 @[simp]
-theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
-    Monotone (WithBot.map f) ↔ Monotone f :=
+theorem monotone_map_iff {f : α → β} : Monotone (WithBot.map f) ↔ Monotone f :=
   monotone_iff.trans <| by simp [Monotone]
 #align with_bot.monotone_map_iff WithBot.monotone_map_iff
 
 alias ⟨_, _root_.Monotone.withBot_map⟩ := monotone_map_iff
 #align monotone.with_bot_map Monotone.withBot_map
 
-theorem strictMono_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
-    StrictMono f ↔ StrictMono (λ a => f a : α → β) ∧ ∀ x : α, f ⊥ < f x :=
+theorem strictMono_iff {f : WithBot α → β} :
+    StrictMono f ↔ StrictMono (fun a => f a : α → β) ∧ ∀ x : α, f ⊥ < f x :=
   ⟨fun h => ⟨h.comp WithBot.coe_strictMono, fun _ => h (bot_lt_coe _)⟩, fun h =>
     WithBot.forall.2
       ⟨WithBot.forall.2 ⟨flip absurd (lt_irrefl _), fun x _ => h.2 x⟩, fun _ =>
         WithBot.forall.2 ⟨fun h => (not_lt_bot h).elim, fun _ hle => h.1 (coe_lt_coe.1 hle)⟩⟩⟩
 #align with_bot.strict_mono_iff WithBot.strictMono_iff
 
-theorem strictAnti_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
+theorem strictAnti_iff {f : WithBot α → β} :
     StrictAnti f ↔ StrictAnti (λ a => f a : α → β) ∧ ∀ x : α, f x < f ⊥ :=
   strictMono_iff (β := βᵒᵈ)
 
 @[simp]
-theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
+theorem strictMono_map_iff {f : α → β} :
     StrictMono (WithBot.map f) ↔ StrictMono f :=
   strictMono_iff.trans <| by simp [StrictMono, bot_lt_coe]
 #align with_bot.strict_mono_map_iff WithBot.strictMono_map_iff
@@ -389,30 +402,24 @@ theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
 alias ⟨_, _root_.StrictMono.withBot_map⟩ := strictMono_map_iff
 #align strict_mono.with_bot_map StrictMono.withBot_map
 
-theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
+theorem map_le_iff (f : α → β) (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
     ∀ a b : WithBot α, a.map f ≤ b.map f ↔ a ≤ b
   | ⊥, _ => by simp only [map_bot, bot_le]
   | (a : α), ⊥ => by simp only [map_coe, map_bot, coe_ne_bot, not_coe_le_bot _]
   | (a : α), (b : α) => by simpa only [map_coe, coe_le_coe] using mono_iff
 #align with_bot.map_le_iff WithBot.map_le_iff
 
-theorem le_coe_unbot' [Preorder α] : ∀ (a : WithBot α) (b : α), a ≤ a.unbot' b
+theorem le_coe_unbot' : ∀ (a : WithBot α) (b : α), a ≤ a.unbot' b
   | (a : α), _ => le_rfl
   | ⊥, _ => bot_le
 #align with_bot.le_coe_unbot' WithBot.le_coe_unbot'
 
-theorem unbot'_le_iff [LE α] {a : WithBot α} {b c : α} (h : a = ⊥ → b ≤ c) :
-    a.unbot' b ≤ c ↔ a ≤ c := by
-  cases a
-  · simpa using h rfl
-  · simp [some_eq_coe]
-#align with_bot.unbot'_bot_le_iff WithBot.unbot'_le_iff
+@[simp]
+theorem lt_coe_bot [OrderBot α] : ∀ {x : WithBot α}, x < (⊥ : α) ↔ x = ⊥
+  | (x : α) => by simp
+  | ⊥ => by simp
 
-theorem unbot'_lt_iff [LT α] {a : WithBot α} {b c : α} (h : a = ⊥ → b < c) :
-    a.unbot' b < c ↔ a < c := by
-  cases a
-  · simpa [bot_lt_coe] using h rfl
-  · simp [some_eq_coe]
+end Preorder
 
 instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
   { WithBot.partialOrder, @WithBot.orderBot α _ with
@@ -422,13 +429,10 @@ instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
     sup_le := fun o₁ o₂ o₃ h₁ h₂ a ha => by
       cases' o₁ with b <;> cases' o₂ with c <;> cases ha
       · exact h₂ a rfl
-
       · exact h₁ a rfl
-
       · rcases h₁ b rfl with ⟨d, ⟨⟩, h₁'⟩
         simp at h₂
-        exact ⟨d, rfl, sup_le h₁' h₂⟩
-         }
+        exact ⟨d, rfl, sup_le h₁' h₂⟩ }
 
 theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithBot α) = (a : WithBot α) ⊔ b :=
   rfl
@@ -919,6 +923,10 @@ theorem le_untop_iff {a : α} {b : WithTop α} (h : b ≠ ⊤) :
     a ≤ untop b h ↔ (a : WithTop α) ≤ b :=
   @WithBot.unbot_le_iff αᵒᵈ _ _ _ _
 
+theorem le_untop'_iff {a : WithTop α} {b c : α} (h : a = ⊤ → c ≤ b) :
+    c ≤ a.untop' b ↔ c ≤ a :=
+  WithBot.unbot'_le_iff (α := αᵒᵈ) h
+
 end LE
 
 section LT
@@ -958,6 +966,10 @@ theorem ofDual_lt_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a < WithT
   Iff.rfl
 #align with_top.of_dual_lt_of_dual_iff WithTop.ofDual_lt_ofDual_iff
 
+theorem lt_untop'_iff {a : WithTop α} {b c : α} (h : a = ⊤ → c < b) :
+    c < a.untop' b ↔ c < a :=
+  WithBot.unbot'_lt_iff (α := αᵒᵈ) h
+
 end LT
 
 end WithTop
@@ -1108,6 +1120,7 @@ theorem some_lt_some : @LT.lt (WithTop α) _ (Option.some a) (Option.some b) ↔
   coe_lt_coe
 #align with_top.some_lt_some WithTop.some_lt_some
 
+@[simp]
 theorem coe_lt_top (a : α) : (a : WithTop α) < ⊤ := by
   simp [← toDual_lt_toDual_iff, WithBot.bot_lt_coe]
 #align with_top.coe_lt_top WithTop.coe_lt_top
@@ -1151,15 +1164,17 @@ instance partialOrder [PartialOrder α] : PartialOrder (WithTop α) where
   le_antisymm := @le_antisymm  (WithBot αᵒᵈ)ᵒᵈ _
 #align with_top.partial_order WithTop.partialOrder
 
-theorem coe_strictMono [Preorder α] : StrictMono (fun a : α => (a : WithTop α)) :=
-  fun _ _ => some_lt_some.2
+section Preorder
+
+variable [Preorder α] [Preorder β]
+
+theorem coe_strictMono : StrictMono (fun a : α => (a : WithTop α)) := fun _ _ => some_lt_some.2
 #align with_top.coe_strict_mono WithTop.coe_strictMono
 
-theorem coe_mono [Preorder α] : Monotone (fun a : α => (a : WithTop α)) :=
-  fun _ _ => coe_le_coe.2
+theorem coe_mono : Monotone (fun a : α => (a : WithTop α)) := fun _ _ => coe_le_coe.2
 #align with_top.coe_mono WithTop.coe_mono
 
-theorem monotone_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
+theorem monotone_iff {f : WithTop α → β} :
     Monotone f ↔ Monotone (fun (a : α) => f a) ∧ ∀ x : α, f x ≤ f ⊤ :=
   ⟨fun h => ⟨h.comp WithTop.coe_mono, fun _ => h le_top⟩, fun h =>
     WithTop.forall.2
@@ -1168,15 +1183,14 @@ theorem monotone_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
 #align with_top.monotone_iff WithTop.monotone_iff
 
 @[simp]
-theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
-    Monotone (WithTop.map f) ↔ Monotone f :=
+theorem monotone_map_iff {f : α → β} : Monotone (WithTop.map f) ↔ Monotone f :=
   monotone_iff.trans <| by simp [Monotone]
 #align with_top.monotone_map_iff WithTop.monotone_map_iff
 
 alias ⟨_, _root_.Monotone.withTop_map⟩ := monotone_map_iff
 #align monotone.with_top_map Monotone.withTop_map
 
-theorem strictMono_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
+theorem strictMono_iff {f : WithTop α → β} :
     StrictMono f ↔ StrictMono (fun (a : α) => f a) ∧ ∀ x : α, f x < f ⊤ :=
   ⟨fun h => ⟨h.comp WithTop.coe_strictMono, fun _ => h (coe_lt_top _)⟩, fun h =>
     WithTop.forall.2
@@ -1184,41 +1198,33 @@ theorem strictMono_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
         WithTop.forall.2 ⟨fun _ => h.2 x, fun _ hle => h.1 (coe_lt_coe.1 hle)⟩⟩⟩
 #align with_top.strict_mono_iff WithTop.strictMono_iff
 
-theorem strictAnti_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
+theorem strictAnti_iff {f : WithTop α → β} :
     StrictAnti f ↔ StrictAnti (λ a => f a : α → β) ∧ ∀ x : α, f ⊤ < f x :=
   strictMono_iff (β := βᵒᵈ)
 
 @[simp]
-theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
-    StrictMono (WithTop.map f) ↔ StrictMono f :=
+theorem strictMono_map_iff {f : α → β} : StrictMono (WithTop.map f) ↔ StrictMono f :=
   strictMono_iff.trans <| by simp [StrictMono, coe_lt_top]
 #align with_top.strict_mono_map_iff WithTop.strictMono_map_iff
 
 alias ⟨_, _root_.StrictMono.withTop_map⟩ := strictMono_map_iff
 #align strict_mono.with_top_map StrictMono.withTop_map
 
-theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (a b : WithTop α)
+theorem map_le_iff (f : α → β) (a b : WithTop α)
     (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
     a.map f ≤ b.map f ↔ a ≤ b := by
   erw [← toDual_le_toDual_iff, toDual_map, toDual_map, WithBot.map_le_iff, toDual_le_toDual_iff]
   simp [mono_iff]
 #align with_top.map_le_iff WithTop.map_le_iff
 
-theorem coe_untop'_le [Preorder α] : ∀ (a : WithTop α) (b : α), a.untop' b ≤ a
-  | (a : α), _ => le_rfl
-  | ⊤, _ => le_top
+theorem coe_untop'_le (a : WithTop α) (b : α) : a.untop' b ≤ a :=
+  WithBot.le_coe_unbot' (α := αᵒᵈ) a b
 
-theorem le_untop'_iff [LE α] {a : WithTop α} {b c : α} (h : a = ⊤ → c ≤ b) :
-    c ≤ a.untop' b ↔ c ≤ a := by
-  cases a
-  · simpa using h rfl
-  · simp [some_eq_coe]
+@[simp]
+theorem coe_top_lt [OrderTop α] {x : WithTop α} : (⊤ : α) < x ↔ x = ⊤ :=
+  WithBot.lt_coe_bot (α := αᵒᵈ)
 
-theorem lt_untop'_iff [LT α] {a : WithTop α} {b c : α} (h : a = ⊤ → c < b) :
-    c < a.untop' b ↔ c < a := by
-  cases a
-  · simpa [none_eq_top, coe_lt_top] using h rfl
-  · simp [some_eq_coe]
+end Preorder
 
 instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithTop α) :=
   { WithTop.partialOrder with

chore(Order/WithBot): use OrderDual trick to golf some proofs (#9897)

Move WithBot.instWellFoundedGT up.
Use the OrderDual trick to golf some proofs.

1612bb7f

Diff

@@ -520,6 +520,20 @@ instance instWellFoundedLT [LT α] [WellFoundedLT α] : WellFoundedLT (WithBot 
         | (b : α), hlt => ih _ (some_lt_some.1 hlt)
 #align with_bot.well_founded_lt WithBot.instWellFoundedLT
 
+instance _root_.WithBot.instWellFoundedGT [LT α] [WellFoundedGT α] : WellFoundedGT (WithBot α) where
+  wf :=
+  have acc_some (a : α) : Acc ((· > ·) : WithBot α → WithBot α → Prop) a :=
+    (wellFounded_gt.1 a).rec fun _ _ ih =>
+      .intro _ fun
+        | (b : α), hlt => ih _ (coe_lt_coe.1 hlt)
+        | ⊥, hlt => absurd hlt (not_lt_none _)
+  .intro fun
+    | (a : α) => acc_some a
+    | ⊥ => .intro _ fun
+      | (b : α), _ => acc_some b
+      | ⊥, hlt => absurd hlt (not_lt_none _)
+#align with_bot.well_founded_gt WithBot.instWellFoundedGT
+
 instance denselyOrdered [LT α] [DenselyOrdered α] [NoMinOrder α] : DenselyOrdered (WithBot α) :=
   ⟨fun a b =>
     match a, b with
@@ -1129,17 +1143,12 @@ end LT
 instance preorder [Preorder α] : Preorder (WithTop α) where
   le := (· ≤ ·)
   lt := (· < ·)
-  lt_iff_le_not_le := by simp [← toDual_lt_toDual_iff, lt_iff_le_not_le]
-  le_refl _ := toDual_le_toDual_iff.mp le_rfl
-  le_trans _ _ _ := by
-    simp_rw [← toDual_le_toDual_iff]
-    exact Function.swap le_trans
+  lt_iff_le_not_le := @lt_iff_le_not_le (WithBot αᵒᵈ)ᵒᵈ _
+  le_refl := @le_refl (WithBot αᵒᵈ)ᵒᵈ _
+  le_trans := @le_trans (WithBot αᵒᵈ)ᵒᵈ _
 
-instance partialOrder [PartialOrder α] : PartialOrder (WithTop α) :=
-  { WithTop.preorder with
-    le_antisymm := fun _ _ => by
-      simp_rw [← toDual_le_toDual_iff]
-      exact Function.swap le_antisymm }
+instance partialOrder [PartialOrder α] : PartialOrder (WithTop α) where
+  le_antisymm := @le_antisymm  (WithBot αᵒᵈ)ᵒᵈ _
 #align with_top.partial_order WithTop.partialOrder
 
 theorem coe_strictMono [Preorder α] : StrictMono (fun a : α => (a : WithTop α)) :=
@@ -1214,18 +1223,9 @@ theorem lt_untop'_iff [LT α] {a : WithTop α} {b c : α} (h : a = ⊤ → c < b
 instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithTop α) :=
   { WithTop.partialOrder with
     inf := Option.liftOrGet (· ⊓ ·),
-    inf_le_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
-    inf_le_right := fun o₁ o₂ a ha => by cases ha; cases o₁ <;> simp [Option.liftOrGet],
-    le_inf := fun o₁ o₂ o₃ h₁ h₂ a ha => by
-      cases' o₂ with b <;> cases' o₃ with c <;> cases ha
-      · exact h₂ a rfl
-
-      · exact h₁ a rfl
-
-      · rcases h₁ b rfl with ⟨d, ⟨⟩, h₁'⟩
-        simp at h₂
-        exact ⟨d, rfl, le_inf h₁' h₂⟩
-         }
+    inf_le_left := @inf_le_left (WithBot αᵒᵈ)ᵒᵈ _
+    inf_le_right := @inf_le_right (WithBot αᵒᵈ)ᵒᵈ _
+    le_inf := @le_inf (WithBot αᵒᵈ)ᵒᵈ _ }
 
 theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithTop α) = (a : WithTop α) ⊓ b :=
   rfl
@@ -1234,17 +1234,9 @@ theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithTop α) =
 instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithTop α) :=
   { WithTop.partialOrder with
     sup := Option.map₂ (· ⊔ ·),
-    le_sup_left := fun o₁ o₂ a ha => by
-      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
-      exact ⟨_, rfl, le_sup_left⟩,
-    le_sup_right := fun o₁ o₂ a ha => by
-      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
-      exact ⟨_, rfl, le_sup_right⟩,
-    sup_le := fun o₁ o₂ o₃ h₁ h₂ a ha => by
-      cases ha
-      rcases h₁ a rfl with ⟨b, ⟨⟩, ab⟩
-      rcases h₂ a rfl with ⟨c, ⟨⟩, ac⟩
-      exact ⟨_, rfl, sup_le ab ac⟩ }
+    le_sup_left := @le_sup_left (WithBot αᵒᵈ)ᵒᵈ _
+    le_sup_right := @le_sup_right (WithBot αᵒᵈ)ᵒᵈ _
+    sup_le := @sup_le (WithBot αᵒᵈ)ᵒᵈ _ }
 
 theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithTop α) = (a : WithTop α) ⊔ b :=
   rfl
@@ -1255,13 +1247,7 @@ instance lattice [Lattice α] : Lattice (WithTop α) :=
 
 instance distribLattice [DistribLattice α] : DistribLattice (WithTop α) :=
   { WithTop.lattice with
-    le_sup_inf := fun o₁ o₂ o₃ =>
-      match o₁, o₂, o₃ with
-      | ⊤, _, _ => le_rfl
-      | (a₁ : α), ⊤, ⊤ => le_rfl
-      | (a₁ : α), ⊤, (a₃ : α) => le_rfl
-      | (a₁ : α), (a₂ : α), ⊤ => le_rfl
-      | (a₁ : α), (a₂ : α), (a₃ : α) => coe_le_coe.mpr le_sup_inf }
+    le_sup_inf := @le_sup_inf (WithBot αᵒᵈ)ᵒᵈ _ }
 
 -- porting note: added, previously this was found via unfolding `WithTop`
 instance decidableEq [DecidableEq α] : DecidableEq (WithTop α) := instDecidableEqOption
@@ -1296,47 +1282,16 @@ theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max
   rfl
 #align with_top.coe_max WithTop.coe_max
 
-instance instWellFoundedLT [LT α] [WellFoundedLT α] : WellFoundedLT (WithTop α) where
-  wf :=
-  have not_top_lt : ∀ a : WithTop α, ¬ ⊤ < a := (fun.)
-  have acc_some (a : α) : Acc ((· < ·) : WithTop α → WithTop α → Prop) a :=
-    (wellFounded_lt.1 a).rec fun _ _ ih =>
-      .intro _ fun
-        | (b : α), hlt => ih _ (some_lt_some.1 hlt)
-        | ⊤, hlt => nomatch not_top_lt _ hlt
-  .intro fun
-    | (a : α) => acc_some a
-    | ⊤ => .intro _ fun
-      | (b : α), _ => acc_some b
-      | ⊤, hlt => nomatch not_top_lt _ hlt
+instance instWellFoundedLT [LT α] [WellFoundedLT α] : WellFoundedLT (WithTop α) :=
+  inferInstanceAs <| WellFoundedLT (WithBot αᵒᵈ)ᵒᵈ
 #align with_top.well_founded_lt WithTop.instWellFoundedLT
 
 open OrderDual
 
-instance instWellFoundedGT [LT α] [WellFoundedGT α] : WellFoundedGT (WithTop α) where
-  wf := ⟨fun a => by
-    -- ideally, use RelHomClass.acc, but that is defined later
-    have : Acc (· < ·) (WithTop.toDual a) := wellFounded_lt.apply _
-    revert this
-    generalize ha : WithBot.toDual a = b
-    intro ac
-    induction' ac with _ H IH generalizing a
-    subst ha
-    exact ⟨_, fun a' h => IH (WithTop.toDual a') (toDual_lt_toDual.mpr h) _ rfl⟩⟩
+instance instWellFoundedGT [LT α] [WellFoundedGT α] : WellFoundedGT (WithTop α) :=
+  inferInstanceAs <| WellFoundedGT (WithBot αᵒᵈ)ᵒᵈ
 #align with_top.well_founded_gt WithTop.instWellFoundedGT
 
-instance _root_.WithBot.instWellFoundedGT [LT α] [WellFoundedGT α] : WellFoundedGT (WithBot α) where
-  wf := ⟨fun a => by
-    -- ideally, use RelHomClass.acc, but that is defined later
-    have : Acc (· < ·) (WithBot.toDual a) := wellFounded_lt.apply _
-    revert this
-    generalize ha : WithBot.toDual a = b
-    intro ac
-    induction' ac with _ H IH generalizing a
-    subst ha
-    exact ⟨_, fun a' h => IH (WithBot.toDual a') (toDual_lt_toDual.mpr h) _ rfl⟩⟩
-#align with_bot.well_founded_gt WithBot.instWellFoundedGT
-
 instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithTop α) (· < ·) :=
   ⟨by

fix(WithBot): fix 2 typos (#9900)

8ca0042c

Diff

@@ -301,7 +301,7 @@ theorem lt_iff_exists_coe : ∀ {a b : WithBot α}, a < b ↔ ∃ p : α, b = p
   | a, none => iff_of_false (not_lt_none _) <| by simp [none_eq_bot]
 #align with_bot.lt_iff_exists_coe WithBot.lt_iff_exists_coe
 
-theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a, x = ↑a → a < b
+theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a : α, x = ↑a → a < b
   | Option.some b => by simp [some_eq_coe, coe_eq_coe, coe_lt_coe]
   | none => by simp [none_eq_bot, bot_lt_coe]
 #align with_bot.lt_coe_iff WithBot.lt_coe_iff
@@ -1114,7 +1114,8 @@ theorem lt_iff_exists_coe {a b : WithTop α} : a < b ↔ ∃ p : α, a = p ∧ 
   exact exists_congr fun _ => and_congr_left' Iff.rfl
 #align with_top.lt_iff_exists_coe WithTop.lt_iff_exists_coe
 
-theorem coe_lt_iff {x : WithTop α} : ↑a < x ↔ ∀ b, x = ↑b → a < b := by simp
+theorem coe_lt_iff {x : WithTop α} : ↑a < x ↔ ∀ b : α, x = ↑b → a < b :=
+  WithBot.lt_coe_iff (α := αᵒᵈ)
 #align with_top.coe_lt_iff WithTop.coe_lt_iff
 
 /-- A version of `lt_top_iff_ne_top` for `WithTop` that only requires `LT α`, not

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

@@ -7,6 +7,7 @@ import Mathlib.Logic.Nontrivial.Basic
 import Mathlib.Order.BoundedOrder
 import Mathlib.Data.Option.NAry
 import Mathlib.Tactic.Lift
+import Mathlib.Data.Option.Basic
 
 #align_import order.with_bot from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"

style: cleanup by putting by on the same line as := (#8407)

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

5e9b46ed

Diff

@@ -198,8 +198,8 @@ instance (priority := 10) le : LE (WithBot α) :=
   ⟨fun o₁ o₂ : Option α => ∀ a ∈ o₁, ∃ b ∈ o₂, a ≤ b⟩
 
 @[simp]
-theorem some_le_some : @LE.le (WithBot α) _ (Option.some a) (Option.some b) ↔ a ≤ b :=
-  by simp [LE.le]
+theorem some_le_some : @LE.le (WithBot α) _ (Option.some a) (Option.some b) ↔ a ≤ b := by
+  simp [LE.le]
 #align with_bot.some_le_some WithBot.some_le_some
 
 @[simp, norm_cast]

perf(FunLike.Basic): beta reduce CoeFun.coe (#7905)

This eliminates (fun a ↦ β) α in the type when applying a FunLike.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

e194c756

Diff

@@ -893,7 +893,7 @@ protected theorem _root_.IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) :=
   -- defeq to is_max_to_dual_iff.mp (is_max.with_bot _), but that breaks API boundary
   intro _ hb
   rw [← toDual_le_toDual_iff] at hb
-  simpa [toDual_le_iff] using (IsMax.withBot h : IsMax (toDual a : WithBot αᵒᵈ)) hb
+  simpa [toDual_le_iff] using h.toDual.withBot hb
 #align is_min.with_top IsMin.withTop
 
 theorem untop_le_iff {a : WithTop α} {b : α} (h : a ≠ ⊤) :
@@ -1318,7 +1318,6 @@ instance instWellFoundedGT [LT α] [WellFoundedGT α] : WellFoundedGT (WithTop 
     revert this
     generalize ha : WithBot.toDual a = b
     intro ac
-    dsimp at ac
     induction' ac with _ H IH generalizing a
     subst ha
     exact ⟨_, fun a' h => IH (WithTop.toDual a') (toDual_lt_toDual.mpr h) _ rfl⟩⟩
@@ -1331,7 +1330,6 @@ instance _root_.WithBot.instWellFoundedGT [LT α] [WellFoundedGT α] : WellFound
     revert this
     generalize ha : WithBot.toDual a = b
     intro ac
-    dsimp at ac
     induction' ac with _ H IH generalizing a
     subst ha
     exact ⟨_, fun a' h => IH (WithBot.toDual a') (toDual_lt_toDual.mpr h) _ rfl⟩⟩

feat: Shorthands for well-foundedness of < and > (#7865)

We already have WellFoundedLT/WellFoundedGT as wrappers around IsWellFounded, but we didn't have the corresponding wrapper lemmas.

0030ea77

Diff

@@ -507,17 +507,17 @@ theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = ma
   rfl
 #align with_bot.coe_max WithBot.coe_max
 
-theorem wellFounded_lt [LT α] (h : @WellFounded α (· < ·)) :
-    @WellFounded (WithBot α) (· < ·) :=
+instance instWellFoundedLT [LT α] [WellFoundedLT α] : WellFoundedLT (WithBot α) where
+  wf :=
   have not_lt_bot : ∀ a : WithBot α, ¬ a < ⊥ := (fun.)
   have acc_bot := ⟨_, by simp [not_lt_bot]⟩
   .intro fun
     | ⊥ => acc_bot
-    | (a : α) => (h.1 a).rec fun a _ ih =>
+    | (a : α) => (wellFounded_lt.1 a).rec fun a _ ih =>
       .intro _ fun
         | ⊥, _ => acc_bot
         | (b : α), hlt => ih _ (some_lt_some.1 hlt)
-#align with_bot.well_founded_lt WithBot.wellFounded_lt
+#align with_bot.well_founded_lt WithBot.instWellFoundedLT
 
 instance denselyOrdered [LT α] [DenselyOrdered α] [NoMinOrder α] : DenselyOrdered (WithBot α) :=
   ⟨fun a b =>
@@ -1294,11 +1294,11 @@ theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max
   rfl
 #align with_top.coe_max WithTop.coe_max
 
-theorem wellFounded_lt [LT α] (h : @WellFounded α (· < ·)) :
-    @WellFounded (WithTop α) (· < ·) :=
+instance instWellFoundedLT [LT α] [WellFoundedLT α] : WellFoundedLT (WithTop α) where
+  wf :=
   have not_top_lt : ∀ a : WithTop α, ¬ ⊤ < a := (fun.)
   have acc_some (a : α) : Acc ((· < ·) : WithTop α → WithTop α → Prop) a :=
-    (h.1 a).rec fun _ _ ih =>
+    (wellFounded_lt.1 a).rec fun _ _ ih =>
       .intro _ fun
         | (b : α), hlt => ih _ (some_lt_some.1 hlt)
         | ⊤, hlt => nomatch not_top_lt _ hlt
@@ -1307,16 +1307,14 @@ theorem wellFounded_lt [LT α] (h : @WellFounded α (· < ·)) :
     | ⊤ => .intro _ fun
       | (b : α), _ => acc_some b
       | ⊤, hlt => nomatch not_top_lt _ hlt
-#align with_top.well_founded_lt WithTop.wellFounded_lt
+#align with_top.well_founded_lt WithTop.instWellFoundedLT
 
 open OrderDual
 
-theorem wellFounded_gt [LT α] (h : @WellFounded α (· > ·)) :
-    @WellFounded (WithTop α) (· > ·) :=
-  ⟨fun a => by
-    -- ideally, use rel_hom_class.acc, but that is defined later
-    have : Acc (· < ·) (WithTop.toDual a) := WellFounded.apply (WithBot.wellFounded_lt
-      (by convert h using 1)) _
+instance instWellFoundedGT [LT α] [WellFoundedGT α] : WellFoundedGT (WithTop α) where
+  wf := ⟨fun a => by
+    -- ideally, use RelHomClass.acc, but that is defined later
+    have : Acc (· < ·) (WithTop.toDual a) := wellFounded_lt.apply _
     revert this
     generalize ha : WithBot.toDual a = b
     intro ac
@@ -1324,14 +1322,12 @@ theorem wellFounded_gt [LT α] (h : @WellFounded α (· > ·)) :
     induction' ac with _ H IH generalizing a
     subst ha
     exact ⟨_, fun a' h => IH (WithTop.toDual a') (toDual_lt_toDual.mpr h) _ rfl⟩⟩
-#align with_top.well_founded_gt WithTop.wellFounded_gt
-
-theorem _root_.WithBot.wellFounded_gt [LT α] (h : @WellFounded α (· > ·)) :
-    @WellFounded (WithBot α) (· > ·) :=
-  ⟨fun a => by
-    -- ideally, use rel_hom_class.acc, but that is defined later
-    have : Acc (· < ·) (WithBot.toDual a) :=
-      WellFounded.apply (WithTop.wellFounded_lt (by convert h using 1)) _
+#align with_top.well_founded_gt WithTop.instWellFoundedGT
+
+instance _root_.WithBot.instWellFoundedGT [LT α] [WellFoundedGT α] : WellFoundedGT (WithBot α) where
+  wf := ⟨fun a => by
+    -- ideally, use RelHomClass.acc, but that is defined later
+    have : Acc (· < ·) (WithBot.toDual a) := wellFounded_lt.apply _
     revert this
     generalize ha : WithBot.toDual a = b
     intro ac
@@ -1339,7 +1335,7 @@ theorem _root_.WithBot.wellFounded_gt [LT α] (h : @WellFounded α (· > ·)) :
     induction' ac with _ H IH generalizing a
     subst ha
     exact ⟨_, fun a' h => IH (WithBot.toDual a') (toDual_lt_toDual.mpr h) _ rfl⟩⟩
-#align with_bot.well_founded_gt WithBot.wellFounded_gt
+#align with_bot.well_founded_gt WithBot.instWellFoundedGT
 
 instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithTop α) (· < ·) :=
@@ -1351,8 +1347,7 @@ instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     · simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (· < ·) _ a b⟩
 #align with_top.trichotomous.lt WithTop.trichotomous.lt
 
-instance IsWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] :
-    IsWellOrder (WithTop α) (· < ·) where wf := wellFounded_lt h.wf
+instance IsWellOrder.lt [Preorder α] [IsWellOrder α (· < ·)] : IsWellOrder (WithTop α) (· < ·) where
 #align with_top.is_well_order.lt WithTop.IsWellOrder.lt
 
 instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
@@ -1365,8 +1360,7 @@ instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     · simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (· > ·) _ a b⟩
 #align with_top.trichotomous.gt WithTop.trichotomous.gt
 
-instance IsWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] :
-    IsWellOrder (WithTop α) (· > ·) where wf := wellFounded_gt h.wf
+instance IsWellOrder.gt [Preorder α] [IsWellOrder α (· > ·)] : IsWellOrder (WithTop α) (· > ·) where
 #align with_top.is_well_order.gt WithTop.IsWellOrder.gt
 
 instance _root_.WithBot.trichotomous.lt [Preorder α] [h : IsTrichotomous α (· < ·)] :
@@ -1374,9 +1368,8 @@ instance _root_.WithBot.trichotomous.lt [Preorder α] [h : IsTrichotomous α (·
   @WithTop.trichotomous.gt αᵒᵈ _ h
 #align with_bot.trichotomous.lt WithBot.trichotomous.lt
 
-instance _root_.WithBot.isWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] :
-    IsWellOrder (WithBot α) (· < ·) :=
-  @WithTop.IsWellOrder.gt αᵒᵈ _ h
+instance _root_.WithBot.isWellOrder.lt [Preorder α] [IsWellOrder α (· < ·)] :
+    IsWellOrder (WithBot α) (· < ·) where
 #align with_bot.is_well_order.lt WithBot.isWellOrder.lt
 
 instance _root_.WithBot.trichotomous.gt [Preorder α] [h : IsTrichotomous α (· > ·)] :

feat(Order/WithBot): add some lemmas (#6275)

The WithTop version of the last 3 lemmas already exists.

b915222e

Diff

@@ -227,6 +227,12 @@ theorem not_coe_le_bot (a : α) : ¬(a : WithBot α) ≤ ⊥ := fun h =>
   Option.not_mem_none _ hb
 #align with_bot.not_coe_le_bot WithBot.not_coe_le_bot
 
+/-- There is a general version `le_bot_iff`, but this lemma does not require a `PartialOrder`. -/
+@[simp]
+protected theorem le_bot_iff : ∀ {a : WithBot α}, a ≤ ⊥ ↔ a = ⊥
+  | (a : α) => by simp [not_coe_le_bot _]
+  | ⊥ => by simp
+
 theorem coe_le : ∀ {o : Option α}, b ∈ o → ((a : WithBot α) ≤ o ↔ a ≤ b)
   | _, rfl => coe_le_coe
 #align with_bot.coe_le WithBot.coe_le
@@ -394,16 +400,18 @@ theorem le_coe_unbot' [Preorder α] : ∀ (a : WithBot α) (b : α), a ≤ a.unb
   | ⊥, _ => bot_le
 #align with_bot.le_coe_unbot' WithBot.le_coe_unbot'
 
-theorem unbot'_bot_le_iff [LE α] [OrderBot α] {a : WithBot α} {b : α} :
-    a.unbot' ⊥ ≤ b ↔ a ≤ b := by
-  cases a <;> simp [none_eq_bot, some_eq_coe]
-#align with_bot.unbot'_bot_le_iff WithBot.unbot'_bot_le_iff
+theorem unbot'_le_iff [LE α] {a : WithBot α} {b c : α} (h : a = ⊥ → b ≤ c) :
+    a.unbot' b ≤ c ↔ a ≤ c := by
+  cases a
+  · simpa using h rfl
+  · simp [some_eq_coe]
+#align with_bot.unbot'_bot_le_iff WithBot.unbot'_le_iff
 
-theorem unbot'_lt_iff [LT α] {a : WithBot α} {b c : α} (ha : a ≠ ⊥) : a.unbot' b < c ↔ a < c := by
+theorem unbot'_lt_iff [LT α] {a : WithBot α} {b c : α} (h : a = ⊥ → b < c) :
+    a.unbot' b < c ↔ a < c := by
   cases a
-  · exact (ha rfl).elim
-  · rw [some_eq_coe, unbot'_coe, coe_lt_coe]
-#align with_bot.unbot'_lt_iff WithBot.unbot'_lt_iff
+  · simpa [bot_lt_coe] using h rfl
+  · simp [some_eq_coe]
 
 instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
   { WithBot.partialOrder, @WithBot.orderBot α _ with
@@ -863,6 +871,12 @@ theorem not_top_le_coe (a : α) : ¬(⊤ : WithTop α) ≤ ↑a :=
   WithBot.not_coe_le_bot (toDual a)
 #align with_top.not_top_le_coe WithTop.not_top_le_coe
 
+/-- There is a general version `top_le_iff`, but this lemma does not require a `PartialOrder`. -/
+@[simp]
+protected theorem top_le_iff : ∀ {a : WithTop α}, ⊤ ≤ a ↔ a = ⊤
+  | (a : α) => by simp [not_top_le_coe _]
+  | ⊤ => by simp
+
 theorem le_coe : ∀ {o : Option α}, a ∈ o → (@LE.le (WithTop α) _ o b ↔ a ≤ b)
   | _, rfl => coe_le_coe
 #align with_top.le_coe WithTop.le_coe
@@ -1179,6 +1193,22 @@ theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (a b : WithTop α
   simp [mono_iff]
 #align with_top.map_le_iff WithTop.map_le_iff
 
+theorem coe_untop'_le [Preorder α] : ∀ (a : WithTop α) (b : α), a.untop' b ≤ a
+  | (a : α), _ => le_rfl
+  | ⊤, _ => le_top
+
+theorem le_untop'_iff [LE α] {a : WithTop α} {b c : α} (h : a = ⊤ → c ≤ b) :
+    c ≤ a.untop' b ↔ c ≤ a := by
+  cases a
+  · simpa using h rfl
+  · simp [some_eq_coe]
+
+theorem lt_untop'_iff [LT α] {a : WithTop α} {b c : α} (h : a = ⊤ → c < b) :
+    c < a.untop' b ↔ c < a := by
+  cases a
+  · simpa [none_eq_top, coe_lt_top] using h rfl
+  · simp [some_eq_coe]
+
 instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithTop α) :=
   { WithTop.partialOrder with
     inf := Option.liftOrGet (· ⊓ ·),

feat(Order/WithBot, Data/Real/ENNReal): coe_injective (#7153)

There already exists NNReal.coe_injective and WithBot.coe_injective, so this adds the analogous ENNReal.coe_injective and WithTop.injective.

b449971a

Diff

@@ -57,7 +57,7 @@ instance nontrivial [Nonempty α] : Nontrivial (WithBot α) :=
 
 open Function
 
-theorem coe_injective : Injective (fun (a : α) => (a : WithBot α)) :=
+theorem coe_injective : Injective ((↑) : α → WithBot α) :=
   Option.some_injective _
 #align with_bot.coe_injective WithBot.coe_injective
 
@@ -586,6 +586,15 @@ instance inhabited : Inhabited (WithTop α) :=
 instance nontrivial [Nonempty α] : Nontrivial (WithTop α) :=
   Option.nontrivial
 
+open Function
+
+theorem coe_injective : Injective ((↑) : α → WithTop α) :=
+  Option.some_injective _
+
+@[norm_cast]
+theorem coe_inj : (a : WithTop α) = b ↔ a = b :=
+  Option.some_inj
+
 protected theorem «forall» {p : WithTop α → Prop} : (∀ x, p x) ↔ p ⊤ ∧ ∀ x : α, p x :=
   Option.forall
 #align with_top.forall WithTop.forall

chore: delay import of Tactic.Common (#7000)

I know that this is contrary to what we've done previously, but:

I'm trying to upstream a great many tactics from Mathlib to Std (essentially, everything that non-mathematicians want too).
This makes it much easier for me to see what is going on, and understand the import requirements (particularly for the "big" tactics norm_num / ring / linarith)
It's actually not as bad as it looks here, because as these tactics move up to Std they will start disappearing again from explicit imports, but Mathlib can happily import all of Std.

(Oh

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

4f3418a7

Diff

@@ -6,6 +6,7 @@ Authors: Johannes Hölzl
 import Mathlib.Logic.Nontrivial.Basic
 import Mathlib.Order.BoundedOrder
 import Mathlib.Data.Option.NAry
+import Mathlib.Tactic.Lift
 
 #align_import order.with_bot from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"

feat: split Logic.Nontrivial (#6959)

This continues reducing the import requirements for the basic algebraic hierarchy.

In combination with #6954 #6955 #6956 #6957, this reduces the imports for Mathlib.Algebra.Field.Defs from

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

560425d2

Diff

@@ -3,6 +3,7 @@ Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
 -/
+import Mathlib.Logic.Nontrivial.Basic
 import Mathlib.Order.BoundedOrder
 import Mathlib.Data.Option.NAry

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -356,7 +356,7 @@ theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
   monotone_iff.trans <| by simp [Monotone]
 #align with_bot.monotone_map_iff WithBot.monotone_map_iff
 
-alias monotone_map_iff ↔ _ _root_.Monotone.withBot_map
+alias ⟨_, _root_.Monotone.withBot_map⟩ := monotone_map_iff
 #align monotone.with_bot_map Monotone.withBot_map
 
 theorem strictMono_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
@@ -377,7 +377,7 @@ theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
   strictMono_iff.trans <| by simp [StrictMono, bot_lt_coe]
 #align with_bot.strict_mono_map_iff WithBot.strictMono_map_iff
 
-alias strictMono_map_iff ↔ _ _root_.StrictMono.withBot_map
+alias ⟨_, _root_.StrictMono.withBot_map⟩ := strictMono_map_iff
 #align strict_mono.with_bot_map StrictMono.withBot_map
 
 theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
@@ -1137,7 +1137,7 @@ theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
   monotone_iff.trans <| by simp [Monotone]
 #align with_top.monotone_map_iff WithTop.monotone_map_iff
 
-alias monotone_map_iff ↔ _ _root_.Monotone.withTop_map
+alias ⟨_, _root_.Monotone.withTop_map⟩ := monotone_map_iff
 #align monotone.with_top_map Monotone.withTop_map
 
 theorem strictMono_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
@@ -1158,7 +1158,7 @@ theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
   strictMono_iff.trans <| by simp [StrictMono, coe_lt_top]
 #align with_top.strict_mono_map_iff WithTop.strictMono_map_iff
 
-alias strictMono_map_iff ↔ _ _root_.StrictMono.withTop_map
+alias ⟨_, _root_.StrictMono.withTop_map⟩ := strictMono_map_iff
 #align strict_mono.with_top_map StrictMono.withTop_map
 
 theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (a b : WithTop α)

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

@@ -19,10 +19,10 @@ Adding a `bot` or a `top` to an order.
 
  -/
 
-variable {α β γ δ : Type _}
+variable {α β γ δ : Type*}
 
 /-- Attach `⊥` to a type. -/
-def WithBot (α : Type _) :=
+def WithBot (α : Type*) :=
   Option α
 #align with_bot WithBot
 
@@ -92,19 +92,19 @@ theorem coe_ne_bot : (a : WithBot α) ≠ ⊥ :=
 
 /-- Recursor for `WithBot` using the preferred forms `⊥` and `↑a`. -/
 @[elab_as_elim]
-def recBotCoe {C : WithBot α → Sort _} (bot : C ⊥) (coe : ∀ a : α, C a) : ∀ n : WithBot α, C n
+def recBotCoe {C : WithBot α → Sort*} (bot : C ⊥) (coe : ∀ a : α, C a) : ∀ n : WithBot α, C n
   | none => bot
   | Option.some a => coe a
 #align with_bot.rec_bot_coe WithBot.recBotCoe
 
 @[simp]
-theorem recBotCoe_bot {C : WithBot α → Sort _} (d : C ⊥) (f : ∀ a : α, C a) :
+theorem recBotCoe_bot {C : WithBot α → Sort*} (d : C ⊥) (f : ∀ a : α, C a) :
     @recBotCoe _ C d f ⊥ = d :=
   rfl
 #align with_bot.rec_bot_coe_bot WithBot.recBotCoe_bot
 
 @[simp]
-theorem recBotCoe_coe {C : WithBot α → Sort _} (d : C ⊥) (f : ∀ a : α, C a) (x : α) :
+theorem recBotCoe_coe {C : WithBot α → Sort*} (d : C ⊥) (f : ∀ a : α, C a) (x : α) :
     @recBotCoe _ C d f ↑x = f x :=
   rfl
 #align with_bot.rec_bot_coe_coe WithBot.recBotCoe_coe
@@ -554,7 +554,7 @@ end WithBot
 
 --TODO(Mario): Construct using order dual on `WithBot`
 /-- Attach `⊤` to a type. -/
-def WithTop (α : Type _) :=
+def WithTop (α : Type*) :=
   Option α
 #align with_top WithTop
 
@@ -612,19 +612,19 @@ theorem coe_ne_top : (a : WithTop α) ≠ ⊤ :=
 
 /-- Recursor for `WithTop` using the preferred forms `⊤` and `↑a`. -/
 @[elab_as_elim]
-def recTopCoe {C : WithTop α → Sort _} (top : C ⊤) (coe : ∀ a : α, C a) : ∀ n : WithTop α, C n
+def recTopCoe {C : WithTop α → Sort*} (top : C ⊤) (coe : ∀ a : α, C a) : ∀ n : WithTop α, C n
   | none => top
   | Option.some a => coe a
 #align with_top.rec_top_coe WithTop.recTopCoe
 
 @[simp]
-theorem recTopCoe_top {C : WithTop α → Sort _} (d : C ⊤) (f : ∀ a : α, C a) :
+theorem recTopCoe_top {C : WithTop α → Sort*} (d : C ⊤) (f : ∀ a : α, C a) :
     @recTopCoe _ C d f ⊤ = d :=
   rfl
 #align with_top.rec_top_coe_top WithTop.recTopCoe_top
 
 @[simp]
-theorem recTopCoe_coe {C : WithTop α → Sort _} (d : C ⊤) (f : ∀ a : α, C a) (x : α) :
+theorem recTopCoe_coe {C : WithTop α → Sort*} (d : C ⊤) (f : ∀ a : α, C a) (x : α) :
     @recTopCoe _ C d f ↑x = f x :=
   rfl
 #align with_top.rec_top_coe_coe WithTop.recTopCoe_coe

chore: tidy various files (#6291)

c4679d7b

Diff

@@ -217,7 +217,7 @@ instance orderTop [OrderTop α] : OrderTop (WithBot α) where
   top := some ⊤
   le_top o a ha := by cases ha; exact ⟨_, rfl, le_top⟩
 
-instance [OrderTop α] : BoundedOrder (WithBot α) :=
+instance instBoundedOrder [OrderTop α] : BoundedOrder (WithBot α) :=
   { WithBot.orderBot, WithBot.orderTop with }
 
 theorem not_coe_le_bot (a : α) : ¬(a : WithBot α) ≤ ⊥ := fun h =>

feat: lemmas about WithBot.unbot (#6124)

34dea34e

Diff

@@ -249,6 +249,11 @@ theorem le_unbot_iff {a : α} {b : WithBot α} (h : b ≠ ⊥) :
   match b, h with
   | some _, _ => simp only [unbot_coe, coe_le_coe]
 
+theorem unbot_le_iff {a : WithBot α} (h : a ≠ ⊥) {b : α} :
+    unbot a h ≤ b ↔ a ≤ (b : WithBot α) := by
+  match a, h with
+  | some _, _ => simp only [unbot_coe, coe_le_coe]
+
 end LE
 
 section LT
@@ -870,6 +875,10 @@ theorem untop_le_iff {a : WithTop α} {b : α} (h : a ≠ ⊤) :
     untop a h ≤ b ↔ a ≤ (b : WithTop α) :=
   @WithBot.le_unbot_iff αᵒᵈ _ _ _ _
 
+theorem le_untop_iff {a : α} {b : WithTop α} (h : b ≠ ⊤) :
+    a ≤ untop b h ↔ (a : WithTop α) ≤ b :=
+  @WithBot.unbot_le_iff αᵒᵈ _ _ _ _
+
 end LE
 
 section LT

feat: lemma about WithBot.unbot (#6061)

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

5d43a7b1

Diff

@@ -109,7 +109,7 @@ theorem recBotCoe_coe {C : WithBot α → Sort _} (d : C ⊥) (f : ∀ a : α, C
   rfl
 #align with_bot.rec_bot_coe_coe WithBot.recBotCoe_coe
 
-/-- Specialization of `Option.get_or_else` to values in `WithBot α` that respects API boundaries.
+/-- Specialization of `Option.getD` to values in `WithBot α` that respects API boundaries.
 -/
 def unbot' (d : α) (x : WithBot α) : α :=
   recBotCoe d id x
@@ -244,6 +244,11 @@ protected theorem _root_.IsMax.withBot (h : IsMax a) : IsMax (a : WithBot α)
   | Option.some _, hb => some_le_some.2 <| h <| some_le_some.1 hb
 #align is_max.with_bot IsMax.withBot
 
+theorem le_unbot_iff {a : α} {b : WithBot α} (h : b ≠ ⊥) :
+    a ≤ unbot b h ↔ (a : WithBot α) ≤ b := by
+  match b, h with
+  | some _, _ => simp only [unbot_coe, coe_le_coe]
+
 end LE
 
 section LT
@@ -679,7 +684,7 @@ theorem ofDual_apply_coe (a : αᵒᵈ) : WithTop.ofDual (a : WithTop αᵒᵈ)
   rfl
 #align with_top.of_dual_apply_coe WithTop.ofDual_apply_coe
 
-/-- Specialization of `Option.get_or_else` to values in `WithTop α` that respects API boundaries.
+/-- Specialization of `Option.getD` to values in `WithTop α` that respects API boundaries.
 -/
 def untop' (d : α) (x : WithTop α) : α :=
   recTopCoe d id x
@@ -861,6 +866,10 @@ protected theorem _root_.IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) :=
   simpa [toDual_le_iff] using (IsMax.withBot h : IsMax (toDual a : WithBot αᵒᵈ)) hb
 #align is_min.with_top IsMin.withTop
 
+theorem untop_le_iff {a : WithTop α} {b : α} (h : a ≠ ⊤) :
+    untop a h ≤ b ↔ a ≤ (b : WithTop α) :=
+  @WithBot.le_unbot_iff αᵒᵈ _ _ _ _
+
 end LE
 
 section LT

chore: use · instead of . (#6085)

898a8e78

Diff

@@ -1289,7 +1289,7 @@ instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     · simp
     · simp
     · simp
-    · simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (. < .) _ a b⟩
+    · simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (· < ·) _ a b⟩
 #align with_top.trichotomous.lt WithTop.trichotomous.lt
 
 instance IsWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] :
@@ -1303,7 +1303,7 @@ instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     · simp
     · simp
     · simp
-    · simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (. > .) _ a b⟩
+    · simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (· > ·) _ a b⟩
 #align with_top.trichotomous.gt WithTop.trichotomous.gt
 
 instance IsWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] :

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2017 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
-
-! This file was ported from Lean 3 source module order.with_bot
-! 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.Order.BoundedOrder
 import Mathlib.Data.Option.NAry
 
+#align_import order.with_bot from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
+
 /-!
 # `WithBot`, `WithTop`

chore: cleanup whitespace (#5988)

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

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

12343aa5

Diff

@@ -1210,7 +1210,7 @@ instance decidableEq [DecidableEq α] : DecidableEq (WithTop α) := instDecidabl
 
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] :
     @DecidableRel (WithTop α) (· ≤ ·) := fun _ _ =>
-  decidable_of_decidable_of_iff  toDual_le_toDual_iff
+  decidable_of_decidable_of_iff toDual_le_toDual_iff
 #align with_top.decidable_le WithTop.decidableLE
 
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] :

chore: remove occurrences of semicolon after space (#5713)

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

c795bd35

Diff

@@ -218,7 +218,7 @@ instance orderBot : OrderBot (WithBot α) :=
 
 instance orderTop [OrderTop α] : OrderTop (WithBot α) where
   top := some ⊤
-  le_top o a ha := by cases ha ; exact ⟨_, rfl, le_top⟩
+  le_top o a ha := by cases ha; exact ⟨_, rfl, le_top⟩
 
 instance [OrderTop α] : BoundedOrder (WithBot α) :=
   { WithBot.orderBot, WithBot.orderTop with }
@@ -304,7 +304,7 @@ instance preorder [Preorder α] : Preorder (WithBot α) where
   lt := (· < ·)
   lt_iff_le_not_le := by
     intros a b
-    cases a <;> cases b <;> simp [lt_iff_le_not_le] ; simp [LE.le, LT.lt]
+    cases a <;> cases b <;> simp [lt_iff_le_not_le]; simp [LE.le, LT.lt]
   le_refl o a ha := ⟨a, ha, le_rfl⟩
   le_trans o₁ o₂ o₃ h₁ h₂ a ha :=
     let ⟨b, hb, ab⟩ := h₁ a ha
@@ -399,8 +399,8 @@ theorem unbot'_lt_iff [LT α] {a : WithBot α} {b c : α} (ha : a ≠ ⊥) : a.u
 instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
   { WithBot.partialOrder, @WithBot.orderBot α _ with
     sup := Option.liftOrGet (· ⊔ ·),
-    le_sup_left := fun o₁ o₂ a ha => by cases ha ; cases o₂ <;> simp [Option.liftOrGet],
-    le_sup_right := fun o₁ o₂ a ha => by cases ha ; cases o₁ <;> simp [Option.liftOrGet],
+    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
+    le_sup_right := fun o₁ o₂ a ha => by cases ha; cases o₁ <;> simp [Option.liftOrGet],
     sup_le := fun o₁ o₂ o₃ h₁ h₂ a ha => by
       cases' o₁ with b <;> cases' o₂ with c <;> cases ha
       · exact h₂ a rfl
@@ -462,7 +462,7 @@ instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (Wit
 #align with_bot.decidable_le WithBot.decidableLE
 
 instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
-  | none, Option.some x => isTrue <| by exists x, rfl ; rintro _ ⟨⟩
+  | none, Option.some x => isTrue <| by exists x, rfl; rintro _ ⟨⟩
   | Option.some x, Option.some y =>
       if h : x < y then isTrue <| by simp [*] else isFalse <| by simp [*]
   | x, none => isFalse <| by rintro ⟨a, ⟨⟨⟩⟩⟩
@@ -835,7 +835,7 @@ instance orderTop : OrderTop (WithTop α) :=
 
 instance orderBot [OrderBot α] : OrderBot (WithTop α) where
   bot := some ⊥
-  bot_le o a ha := by cases ha ; exact ⟨_, rfl, bot_le⟩
+  bot_le o a ha := by cases ha; exact ⟨_, rfl, bot_le⟩
 #align with_top.order_bot WithTop.orderBot
 
 instance boundedOrder [OrderBot α] : BoundedOrder (WithTop α) :=
@@ -1156,8 +1156,8 @@ theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (a b : WithTop α
 instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithTop α) :=
   { WithTop.partialOrder with
     inf := Option.liftOrGet (· ⊓ ·),
-    inf_le_left := fun o₁ o₂ a ha => by cases ha ; cases o₂ <;> simp [Option.liftOrGet],
-    inf_le_right := fun o₁ o₂ a ha => by cases ha ; cases o₁ <;> simp [Option.liftOrGet],
+    inf_le_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
+    inf_le_right := fun o₁ o₂ a ha => by cases ha; cases o₁ <;> simp [Option.liftOrGet],
     le_inf := fun o₁ o₂ o₃ h₁ h₂ a ha => by
       cases' o₂ with b <;> cases' o₃ with c <;> cases ha
       · exact h₂ a rfl

chore: fix focusing dots (#5708)

This PR is the result of running

find . -type f -name "*.lean" -exec sed -i -E 's/^( +)\. /\1· /' {} \;
find . -type f -name "*.lean" -exec sed -i -E 'N;s/^( +·)\n +(.*)$/\1 \2/;P;D' {} \;

which firstly replaces . focusing dots with · and secondly removes isolated instances of such dots, unifying them with the following line. A new rule is placed in the style linter to verify this.

cb02d09e

Diff

@@ -393,7 +393,7 @@ theorem unbot'_bot_le_iff [LE α] [OrderBot α] {a : WithBot α} {b : α} :
 theorem unbot'_lt_iff [LT α] {a : WithBot α} {b c : α} (ha : a ≠ ⊥) : a.unbot' b < c ↔ a < c := by
   cases a
   · exact (ha rfl).elim
-  . rw [some_eq_coe, unbot'_coe, coe_lt_coe]
+  · rw [some_eq_coe, unbot'_coe, coe_lt_coe]
 #align with_bot.unbot'_lt_iff WithBot.unbot'_lt_iff
 
 instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
@@ -1289,10 +1289,10 @@ instance trichotomous.lt [Preorder α] [IsTrichotomous α (· < ·)] :
     IsTrichotomous (WithTop α) (· < ·) :=
   ⟨by
     rintro (a | a) (b | b)
-    . simp
-    . simp
-    . simp
-    . simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (. < .) _ a b⟩
+    · simp
+    · simp
+    · simp
+    · simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (. < .) _ a b⟩
 #align with_top.trichotomous.lt WithTop.trichotomous.lt
 
 instance IsWellOrder.lt [Preorder α] [h : IsWellOrder α (· < ·)] :
@@ -1303,10 +1303,10 @@ instance trichotomous.gt [Preorder α] [IsTrichotomous α (· > ·)] :
     IsTrichotomous (WithTop α) (· > ·) :=
   ⟨by
     rintro (a | a) (b | b)
-    . simp
-    . simp
-    . simp
-    . simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (. > .) _ a b⟩
+    · simp
+    · simp
+    · simp
+    · simpa [some_eq_coe, IsTrichotomous, coe_eq_coe] using @trichotomous α (. > .) _ a b⟩
 #align with_top.trichotomous.gt WithTop.trichotomous.gt
 
 instance IsWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] :

feat: generalize WithBot.wellFounded_lt (#5425)

3c3631e2

Diff

@@ -490,24 +490,16 @@ theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = ma
   rfl
 #align with_bot.coe_max WithBot.coe_max
 
-theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
+theorem wellFounded_lt [LT α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithBot α) (· < ·) :=
-  have acc_bot : Acc ((· < ·) : WithBot α → WithBot α → Prop) ⊥ :=
-    Acc.intro _ fun _ ha => (not_le_of_gt ha bot_le).elim
-  ⟨fun a =>
-    Option.recOn a acc_bot fun a =>
-      Acc.intro _ fun b =>
-        Option.recOn b (fun _ => acc_bot) fun b =>
-          WellFounded.induction h b
-            (show
-              ∀ b : α,
-                (∀ c, c < b → (c : WithBot α) < a → Acc
-                    ((· < ·) : WithBot α → WithBot α → Prop) c) →
-                  (b : WithBot α) < a → Acc ((· < ·) : WithBot α → WithBot α → Prop) b
-              from fun _ ih hba =>
-              Acc.intro _ fun c =>
-                Option.recOn c (fun _ => acc_bot) fun _ hc => ih _
-                  (some_lt_some.1 hc) (lt_trans hc hba))⟩
+  have not_lt_bot : ∀ a : WithBot α, ¬ a < ⊥ := (fun.)
+  have acc_bot := ⟨_, by simp [not_lt_bot]⟩
+  .intro fun
+    | ⊥ => acc_bot
+    | (a : α) => (h.1 a).rec fun a _ ih =>
+      .intro _ fun
+        | ⊥, _ => acc_bot
+        | (b : α), hlt => ih _ (some_lt_some.1 hlt)
 #align with_bot.well_founded_lt WithBot.wellFounded_lt
 
 instance denselyOrdered [LT α] [DenselyOrdered α] [NoMinOrder α] : DenselyOrdered (WithBot α) :=
@@ -1246,25 +1238,24 @@ theorem coe_max [LinearOrder α] (x y : α) : (↑(max x y) : WithTop α) = max
   rfl
 #align with_top.coe_max WithTop.coe_max
 
-theorem wellFounded_lt [Preorder α] (h : @WellFounded α (· < ·)) :
+theorem wellFounded_lt [LT α] (h : @WellFounded α (· < ·)) :
     @WellFounded (WithTop α) (· < ·) :=
-  have acc_some : ∀ a : α, Acc ((· < ·) : WithTop α → WithTop α → Prop) (some a) := fun a =>
-    Acc.intro _
-      (WellFounded.induction h a
-        (show
-          ∀ b, (∀ c, c < b → ∀ d : WithTop α, d < some c → Acc (· < ·) d) →
-            ∀ y : WithTop α, y < some b → Acc (· < ·) y
-          from fun _ ih c =>
-          Option.recOn c (fun hc => (not_lt_of_ge le_top hc).elim) fun _ hc =>
-            Acc.intro _ (ih _ (some_lt_some.1 hc))))
-  ⟨fun a =>
-    Option.recOn a (Acc.intro _ fun y => Option.recOn y
-      (fun h => (lt_irrefl _ h).elim) fun _ _ => acc_some _) acc_some⟩
+  have not_top_lt : ∀ a : WithTop α, ¬ ⊤ < a := (fun.)
+  have acc_some (a : α) : Acc ((· < ·) : WithTop α → WithTop α → Prop) a :=
+    (h.1 a).rec fun _ _ ih =>
+      .intro _ fun
+        | (b : α), hlt => ih _ (some_lt_some.1 hlt)
+        | ⊤, hlt => nomatch not_top_lt _ hlt
+  .intro fun
+    | (a : α) => acc_some a
+    | ⊤ => .intro _ fun
+      | (b : α), _ => acc_some b
+      | ⊤, hlt => nomatch not_top_lt _ hlt
 #align with_top.well_founded_lt WithTop.wellFounded_lt
 
 open OrderDual
 
-theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
+theorem wellFounded_gt [LT α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithTop α) (· > ·) :=
   ⟨fun a => by
     -- ideally, use rel_hom_class.acc, but that is defined later
@@ -1279,7 +1270,7 @@ theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
     exact ⟨_, fun a' h => IH (WithTop.toDual a') (toDual_lt_toDual.mpr h) _ rfl⟩⟩
 #align with_top.well_founded_gt WithTop.wellFounded_gt
 
-theorem _root_.WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
+theorem _root_.WithBot.wellFounded_gt [LT α] (h : @WellFounded α (· > ·)) :
     @WellFounded (WithBot α) (· > ·) :=
   ⟨fun a => by
     -- ideally, use rel_hom_class.acc, but that is defined later

chore: formatting issues (#4947)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

5068808d

Diff

@@ -96,8 +96,8 @@ theorem coe_ne_bot : (a : WithBot α) ≠ ⊥ :=
 /-- Recursor for `WithBot` using the preferred forms `⊥` and `↑a`. -/
 @[elab_as_elim]
 def recBotCoe {C : WithBot α → Sort _} (bot : C ⊥) (coe : ∀ a : α, C a) : ∀ n : WithBot α, C n
-| none => bot
-| Option.some a => coe a
+  | none => bot
+  | Option.some a => coe a
 #align with_bot.rec_bot_coe WithBot.recBotCoe
 
 @[simp]
@@ -614,8 +614,8 @@ theorem coe_ne_top : (a : WithTop α) ≠ ⊤ :=
 /-- Recursor for `WithTop` using the preferred forms `⊤` and `↑a`. -/
 @[elab_as_elim]
 def recTopCoe {C : WithTop α → Sort _} (top : C ⊤) (coe : ∀ a : α, C a) : ∀ n : WithTop α, C n
-| none => top
-| Option.some a => coe a
+  | none => top
+  | Option.some a => coe a
 #align with_top.rec_top_coe WithTop.recTopCoe
 
 @[simp]

feat: port Order.Interval (#3360)

Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com> Co-authored-by: Jon Eugster <eugster.jon@gmail.com>

02858e21

Diff

@@ -43,7 +43,8 @@ instance [Repr α] : Repr (WithBot α) :=
 @[coe, match_pattern] def some : α → WithBot α :=
   Option.some
 
-instance coeTC : CoeTC α (WithBot α) :=
+-- Porting note: changed this from `CoeTC` to `Coe` but I am not 100% confident that's correct.
+instance coe : Coe α (WithBot α) :=
   ⟨some⟩
 
 instance bot : Bot (WithBot α) :=

feat: add Mathlib.Tactic.Common, and import (#4056)

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

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

a4eaf1c4

Diff

@@ -10,7 +10,6 @@ Authors: Johannes Hölzl
 -/
 import Mathlib.Order.BoundedOrder
 import Mathlib.Data.Option.NAry
-import Mathlib.Tactic.Lift
 
 /-!
 # `WithBot`, `WithTop`

fix: re-port Init/Algebra/Order (#4000)

The ad-hoc port was added in #18, but the #aligns were all missing and two defs were incorrectly promoted to an instance.

The absense of these instances reveals some missing instances that need to be added (and were found via unfolding in Lean 3).

3eaefa47

Diff

@@ -451,6 +451,9 @@ instance distribLattice [DistribLattice α] : DistribLattice (WithBot α) :=
       | (a₁ : α), (a₂ : α), ⊥ => inf_le_right
       | (a₁ : α), (a₂ : α), (a₃ : α) => coe_le_coe.mpr le_sup_inf }
 
+-- porting note: added, previously this was found via unfolding `WithBot`
+instance decidableEq [DecidableEq α] : DecidableEq (WithBot α) := instDecidableEqOption
+
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
   | none, x => isTrue fun a h => Option.noConfusion h
   | Option.some x, Option.some y =>
@@ -1210,6 +1213,9 @@ instance distribLattice [DistribLattice α] : DistribLattice (WithTop α) :=
       | (a₁ : α), (a₂ : α), ⊤ => le_rfl
       | (a₁ : α), (a₂ : α), (a₃ : α) => coe_le_coe.mpr le_sup_inf }
 
+-- porting note: added, previously this was found via unfolding `WithTop`
+instance decidableEq [DecidableEq α] : DecidableEq (WithTop α) := instDecidableEqOption
+
 instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] :
     @DecidableRel (WithTop α) (· ≤ ·) := fun _ _ =>
   decidable_of_decidable_of_iff  toDual_le_toDual_iff

refactor: hypothesis naming in custom recursors (#1658)

I have renamed hypotheses in WithBot.recBotCoe, WithTop.recTopCoe and Finset.cons_induction on the basis that rather than

cases f₁ using WithBot.recBotCoe with
| h₁ => …
| h₂ f₁ => …

we would prefer to be able to write

cases f₁ using WithBot.recBotCoe with
| bot => …
| coe f₁ => …

and rather than

induction s using cons_induction with
| h₁ => …
| [@h](https://github.com/h)₂ c s hc ih => …

we would prefer

induction s using cons_induction with
| empty => …
| [@cons](https://github.com/cons) c t hc ih => …

I also tidied up some of inf' stuff in Finset.Lattice by using named arguments to specify the dual type instead of @s and _ _ _.

ac1e75f5

Diff

@@ -95,11 +95,9 @@ theorem coe_ne_bot : (a : WithBot α) ≠ ⊥ :=
 
 /-- Recursor for `WithBot` using the preferred forms `⊥` and `↑a`. -/
 @[elab_as_elim]
-def recBotCoe {C : WithBot α → Sort _} (h₁ : C ⊥) (h₂ : ∀ a : α, C a) :
-  ∀ n : WithBot α, C n
-| none => h₁
-| Option.some a => h₂ a
-
+def recBotCoe {C : WithBot α → Sort _} (bot : C ⊥) (coe : ∀ a : α, C a) : ∀ n : WithBot α, C n
+| none => bot
+| Option.some a => coe a
 #align with_bot.rec_bot_coe WithBot.recBotCoe
 
 @[simp]
@@ -612,9 +610,9 @@ theorem coe_ne_top : (a : WithTop α) ≠ ⊤ :=
 
 /-- Recursor for `WithTop` using the preferred forms `⊤` and `↑a`. -/
 @[elab_as_elim]
-def recTopCoe {C : WithTop α → Sort _} (h₁ : C ⊤) (h₂ : ∀ a : α, C a) : ∀ n : WithTop α, C n
-| none => h₁
-| Option.some a => h₂ a
+def recTopCoe {C : WithTop α → Sort _} (top : C ⊤) (coe : ∀ a : α, C a) : ∀ n : WithTop α, C n
+| none => top
+| Option.some a => coe a
 #align with_top.rec_top_coe WithTop.recTopCoe
 
 @[simp]

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

16edf724

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
 
 ! This file was ported from Lean 3 source module order.with_bot
-! 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.
 -/
@@ -53,6 +53,9 @@ instance bot : Bot (WithBot α) :=
 instance inhabited : Inhabited (WithBot α) :=
   ⟨⊥⟩
 
+instance nontrivial [Nonempty α] : Nontrivial (WithBot α) :=
+  Option.nontrivial
+
 open Function
 
 theorem coe_injective : Injective (fun (a : α) => (a : WithBot α)) :=
@@ -578,6 +581,9 @@ instance top : Top (WithTop α) :=
 instance inhabited : Inhabited (WithTop α) :=
   ⟨⊤⟩
 
+instance nontrivial [Nonempty α] : Nontrivial (WithTop α) :=
+  Option.nontrivial
+
 protected theorem «forall» {p : WithTop α → Prop} : (∀ x, p x) ↔ p ⊤ ∧ ∀ x : α, p x :=
   Option.forall
 #align with_top.forall WithTop.forall

feat: improvements to congr! and convert (#2606)

There is now configuration for congr!, convert, and convert_to to control parts of the congruence algorithm, in particular transparency settings when applying congruence lemmas.
congr! now applies congruence lemmas with reducible transparency by default. This prevents it from unfolding definitions when applying congruence lemmas. It also now tries both the LHS-biased and RHS-biased simp congruence lemmas, with a configuration option to set which it should try first.
There is now a new HEq congruence lemma generator that gives each hypothesis access to the proofs of previous hypotheses. This means that if you have an equality ⊢ ⟨a, x⟩ = ⟨b, y⟩ of sigma types, congr! turns this into goals ⊢ a = b and ⊢ a = b → HEq x y (note that congr! will also auto-introduce a = b for you in the second goal). This congruence lemma generator applies to more cases than the simp congruence lemma generator does.
congr! (and hence convert) are more careful about applying lemmas that don't force definitions to unfold. There were a number of cases in mathlib where the implementation of congr was being abused to unfold definitions.
With set_option trace.congr! true you can see what congr! sees when it is deciding on congruence lemmas.
There is also a bug fix in convert_to to do using 1 when there is no using clause, to match its documentation.

Note that congr! is more capable than congr at finding a way to equate left-hand sides and right-hand sides, so you will frequently need to limit its depth with a using clause. However, there is also a new heuristic to prevent considering unlikely-to-be-provable type equalities (controlled by the typeEqs option), which can help limit the depth automatically.

There is also a predefined configuration that you can invoke with, for example, convert (config := .unfoldSameFun) h, that causes it to behave more like congr, including using default transparency when unfolding.

61ca0ea8

Diff

@@ -1259,7 +1259,7 @@ theorem wellFounded_gt [Preorder α] (h : @WellFounded α (· > ·)) :
   ⟨fun a => by
     -- ideally, use rel_hom_class.acc, but that is defined later
     have : Acc (· < ·) (WithTop.toDual a) := WellFounded.apply (WithBot.wellFounded_lt
-      (by convert h)) _
+      (by convert h using 1)) _
     revert this
     generalize ha : WithBot.toDual a = b
     intro ac
@@ -1274,7 +1274,7 @@ theorem _root_.WithBot.wellFounded_gt [Preorder α] (h : @WellFounded α (· > 
   ⟨fun a => by
     -- ideally, use rel_hom_class.acc, but that is defined later
     have : Acc (· < ·) (WithBot.toDual a) :=
-      WellFounded.apply (WithTop.wellFounded_lt (by convert h)) _
+      WellFounded.apply (WithTop.wellFounded_lt (by convert h using 1)) _
     revert this
     generalize ha : WithBot.toDual a = b
     intro ac

feat: port Data.Real.EReal (#2501)

127bbb26

Diff

@@ -359,6 +359,10 @@ theorem strictMono_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
         WithBot.forall.2 ⟨fun h => (not_lt_bot h).elim, fun _ hle => h.1 (coe_lt_coe.1 hle)⟩⟩⟩
 #align with_bot.strict_mono_iff WithBot.strictMono_iff
 
+theorem strictAnti_iff [Preorder α] [Preorder β] {f : WithBot α → β} :
+    StrictAnti f ↔ StrictAnti (λ a => f a : α → β) ∧ ∀ x : α, f x < f ⊥ :=
+  strictMono_iff (β := βᵒᵈ)
+
 @[simp]
 theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
     StrictMono (WithBot.map f) ↔ StrictMono f :=
@@ -1130,6 +1134,10 @@ theorem strictMono_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
         WithTop.forall.2 ⟨fun _ => h.2 x, fun _ hle => h.1 (coe_lt_coe.1 hle)⟩⟩⟩
 #align with_top.strict_mono_iff WithTop.strictMono_iff
 
+theorem strictAnti_iff [Preorder α] [Preorder β] {f : WithTop α → β} :
+    StrictAnti f ↔ StrictAnti (λ a => f a : α → β) ∧ ∀ x : α, f ⊤ < f x :=
+  strictMono_iff (β := βᵒᵈ)
+
 @[simp]
 theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
     StrictMono (WithTop.map f) ↔ StrictMono f :=

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
 
 ! This file was ported from Lean 3 source module order.with_bot
-! leanprover-community/mathlib commit 995b47e555f1b6297c7cf16855f1023e355219fb
+! leanprover-community/mathlib commit afdb4fa3b32d41106a4a09b371ce549ad7958abd
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -130,6 +130,19 @@ theorem unbot'_coe {α} (d x : α) : unbot' d x = x :=
 theorem coe_eq_coe : (a : WithBot α) = b ↔ a = b := coe_inj
 #align with_bot.coe_eq_coe WithBot.coe_eq_coe
 
+theorem unbot'_eq_iff {d y : α} {x : WithBot α} : unbot' d x = y ↔ x = y ∨ x = ⊥ ∧ y = d := by
+  induction x using recBotCoe <;> simp [@eq_comm _ d]
+#align with_bot.unbot'_eq_iff WithBot.unbot'_eq_iff
+
+@[simp] theorem unbot'_eq_self_iff {d : α} {x : WithBot α} : unbot' d x = d ↔ x = d ∨ x = ⊥ := by
+  simp [unbot'_eq_iff]
+#align with_bot.unbot'_eq_self_iff WithBot.unbot'_eq_self_iff
+
+theorem unbot'_eq_unbot'_iff {d : α} {x y : WithBot α} :
+    unbot' d x = unbot' d y ↔ x = y ∨ x = d ∧ y = ⊥ ∨ x = ⊥ ∧ y = d := by
+ induction y using recBotCoe <;> simp [unbot'_eq_iff, or_comm]
+#align with_bot.unbot'_eq_unbot'_iff WithBot.unbot'_eq_unbot'_iff
+
 /-- Lift a map `f : α → β` to `WithBot α → WithBot β`. Implemented using `Option.map`. -/
 def map (f : α → β) : WithBot α → WithBot β :=
   Option.map f
@@ -276,6 +289,13 @@ theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a, x = ↑a → a < b
   | none => by simp [none_eq_bot, bot_lt_coe]
 #align with_bot.lt_coe_iff WithBot.lt_coe_iff
 
+/-- A version of `bot_lt_iff_ne_bot` for `WithBot` that only requires `LT α`, not
+`PartialOrder α`. -/
+protected theorem bot_lt_iff_ne_bot : ∀ {x : WithBot α}, ⊥ < x ↔ x ≠ ⊥
+  | ⊥ => by simpa using not_lt_none ⊥
+  | (x : α) => by simp [bot_lt_coe]
+#align with_bot.bot_lt_iff_ne_bot WithBot.bot_lt_iff_ne_bot
+
 end LT
 
 instance preorder [Preorder α] : Preorder (WithBot α) where
@@ -680,6 +700,19 @@ theorem coe_eq_coe : (a : WithTop α) = b ↔ a = b :=
   Option.some_inj
 #align with_top.coe_eq_coe WithTop.coe_eq_coe
 
+theorem untop'_eq_iff {d y : α} {x : WithTop α} : untop' d x = y ↔ x = y ∨ x = ⊤ ∧ y = d :=
+  WithBot.unbot'_eq_iff
+#align with_top.untop'_eq_iff WithTop.untop'_eq_iff
+
+@[simp] theorem untop'_eq_self_iff {d : α} {x : WithTop α} : untop' d x = d ↔ x = d ∨ x = ⊤ :=
+  WithBot.unbot'_eq_self_iff
+#align with_top.untop'_eq_self_iff WithTop.untop'_eq_self_iff
+
+theorem untop'_eq_untop'_iff {d : α} {x y : WithTop α} :
+    untop' d x = untop' d y ↔ x = y ∨ x = d ∧ y = ⊤ ∨ x = ⊤ ∧ y = d :=
+  WithBot.unbot'_eq_unbot'_iff
+#align with_top.untop'_eq_untop'_iff WithTop.untop'_eq_untop'_iff
+
 /-- Lift a map `f : α → β` to `WithTop α → WithTop β`. Implemented using `Option.map`. -/
 def map (f : α → β) : WithTop α → WithTop β :=
   Option.map f
@@ -1040,6 +1073,12 @@ theorem lt_iff_exists_coe {a b : WithTop α} : a < b ↔ ∃ p : α, a = p ∧ 
 theorem coe_lt_iff {x : WithTop α} : ↑a < x ↔ ∀ b, x = ↑b → a < b := by simp
 #align with_top.coe_lt_iff WithTop.coe_lt_iff
 
+/-- A version of `lt_top_iff_ne_top` for `WithTop` that only requires `LT α`, not
+`PartialOrder α`. -/
+protected theorem lt_top_iff_ne_top {x : WithTop α} : x < ⊤ ↔ x ≠ ⊤ :=
+  @WithBot.bot_lt_iff_ne_bot αᵒᵈ _ x
+#align with_top.lt_top_iff_ne_top WithTop.lt_top_iff_ne_top
+
 end LT
 
 instance preorder [Preorder α] : Preorder (WithTop α) where

995b47e5

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl
 
 ! This file was ported from Lean 3 source module order.with_bot
-! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
+! leanprover-community/mathlib commit 995b47e555f1b6297c7cf16855f1023e355219fb
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

fix: add some missing type annotations and attrs (#2391)

Fix WithBot.le_coe_iff and WithTop.coe_le_iff.
Mark WithBot.some and WithTop.some as @[match_pattern].
Mark WithBot.coe_eq_coe, WithBot.coe_min, WithBot.coe_max, and WithTop.coe_eq_coe as @[simp]. Lean 3 used applied with_top/with_bot/option lemmas about coe to all three types; now we need to restate them.

200a85b2

Diff

@@ -41,7 +41,7 @@ instance [Repr α] : Repr (WithBot α) :=
     | some a => "↑" ++ repr a⟩
 
 /-- The canonical map from `α` into `WithBot α` -/
-@[coe] def some : α → WithBot α :=
+@[coe, match_pattern] def some : α → WithBot α :=
   Option.some
 
 instance coeTC : CoeTC α (WithBot α) :=
@@ -127,9 +127,7 @@ theorem unbot'_coe {α} (d x : α) : unbot' d x = x :=
   rfl
 #align with_bot.unbot'_coe WithBot.unbot'_coe
 
-@[norm_cast]
-theorem coe_eq_coe : (a : WithBot α) = b ↔ a = b :=
-  Option.some_inj
+theorem coe_eq_coe : (a : WithBot α) = b ↔ a = b := coe_inj
 #align with_bot.coe_eq_coe WithBot.coe_eq_coe
 
 /-- Lift a map `f : α → β` to `WithBot α → WithBot β`. Implemented using `Option.map`. -/
@@ -225,7 +223,7 @@ theorem coe_le_iff : ∀ {x : WithBot α}, (a : WithBot α) ≤ x ↔ ∃ b : α
   | none => iff_of_false (not_coe_le_bot _) <| by simp [none_eq_bot]
 #align with_bot.coe_le_iff WithBot.coe_le_iff
 
-theorem le_coe_iff : ∀ {x : WithBot α}, x ≤ b ↔ ∀ a, x = ↑a → a ≤ b
+theorem le_coe_iff : ∀ {x : WithBot α}, x ≤ b ↔ ∀ a : α, x = ↑a → a ≤ b
   | Option.some b => by simp [some_eq_coe, coe_eq_coe]
   | none => by simp [none_eq_bot]
 #align with_bot.le_coe_iff WithBot.le_coe_iff
@@ -454,14 +452,12 @@ instance linearOrder [LinearOrder α] : LinearOrder (WithBot α) :=
   Lattice.toLinearOrder _
 #align with_bot.linear_order WithBot.linearOrder
 
--- this is not marked simp because the corresponding `WithTop` lemmas are used
-@[norm_cast]
+@[simp, norm_cast]
 theorem coe_min [LinearOrder α] (x y : α) : ((min x y : α) : WithBot α) = min (x : WithBot α) y :=
   rfl
 #align with_bot.coe_min WithBot.coe_min
 
--- this is not marked simp because the corresponding `WithTop` lemmas are used
-@[norm_cast]
+@[simp, norm_cast]
 theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = max (x : WithBot α) y :=
   rfl
 #align with_bot.coe_max WithBot.coe_max
@@ -546,7 +542,7 @@ instance [Repr α] : Repr (WithTop α) :=
     | some a => "↑" ++ repr a⟩
 
 /-- The canonical map from `α` into `WithTop α` -/
-@[coe] def some : α → WithTop α :=
+@[coe, match_pattern] def some : α → WithTop α :=
   Option.some
 
 instance coeTC : CoeTC α (WithTop α) :=
@@ -679,7 +675,7 @@ theorem untop'_coe {α} (d x : α) : untop' d x = x :=
   rfl
 #align with_top.untop'_coe WithTop.untop'_coe
 
-@[norm_cast]
+@[simp, norm_cast] -- porting note: added `simp`
 theorem coe_eq_coe : (a : WithTop α) = b ↔ a = b :=
   Option.some_inj
 #align with_top.coe_eq_coe WithTop.coe_eq_coe
@@ -821,7 +817,7 @@ theorem le_coe_iff {x : WithTop α} : x ≤ b ↔ ∃ a : α, x = a ∧ a ≤ b
   @WithBot.coe_le_iff (αᵒᵈ) _ _ (toDual x)
 #align with_top.le_coe_iff WithTop.le_coe_iff
 
-theorem coe_le_iff {x : WithTop α} : ↑a ≤ x ↔ ∀ b, x = ↑b → a ≤ b :=
+theorem coe_le_iff {x : WithTop α} : ↑a ≤ x ↔ ∀ b : α, x = ↑b → a ≤ b :=
   @WithBot.le_coe_iff (αᵒᵈ) _ _ (toDual x)
 #align with_top.coe_le_iff WithTop.coe_le_iff
 
@@ -1021,8 +1017,8 @@ theorem some_lt_some : @LT.lt (WithTop α) _ (Option.some a) (Option.some b) ↔
   coe_lt_coe
 #align with_top.some_lt_some WithTop.some_lt_some
 
-theorem coe_lt_top (a : α) : (a : WithTop α) < ⊤ :=
-by simp [← toDual_lt_toDual_iff, WithBot.bot_lt_coe]
+theorem coe_lt_top (a : α) : (a : WithTop α) < ⊤ := by
+  simp [← toDual_lt_toDual_iff, WithBot.bot_lt_coe]
 #align with_top.coe_lt_top WithTop.coe_lt_top
 
 @[simp]

Refactor: use Option.map₂ (#1439)

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

da1e6541

Diff

@@ -9,6 +9,7 @@ Authors: Johannes Hölzl
 ! if you have ported upstream changes.
 -/
 import Mathlib.Order.BoundedOrder
+import Mathlib.Data.Option.NAry
 import Mathlib.Tactic.Lift
 
 /-!
@@ -394,14 +395,12 @@ theorem coe_sup [SemilatticeSup α] (a b : α) : ((a ⊔ b : α) : WithBot α) =
 
 instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
   { WithBot.partialOrder, @WithBot.orderBot α _ with
-    inf := fun o₁ o₂ => o₁.bind fun a => o₂.map fun b => a ⊓ b,
+    inf := Option.map₂ (· ⊓ ·),
     inf_le_left := fun o₁ o₂ a ha => by
-      simp [map] at ha
-      rcases ha with ⟨b, rfl, c, rfl, rfl⟩
+      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
       exact ⟨_, rfl, inf_le_left⟩,
     inf_le_right := fun o₁ o₂ a ha => by
-      simp [map] at ha
-      rcases ha with ⟨b, rfl, c, rfl, rfl⟩
+      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
       exact ⟨_, rfl, inf_le_right⟩,
     le_inf := fun o₁ o₂ o₃ h₁ h₂ a ha => by
       cases ha
@@ -1134,14 +1133,12 @@ theorem coe_inf [SemilatticeInf α] (a b : α) : ((a ⊓ b : α) : WithTop α) =
 
 instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithTop α) :=
   { WithTop.partialOrder with
-    sup := fun o₁ o₂ => o₁.bind fun a => o₂.map fun b => a ⊔ b,
+    sup := Option.map₂ (· ⊔ ·),
     le_sup_left := fun o₁ o₂ a ha => by
-      simp [map] at ha
-      rcases ha with ⟨b, rfl, c, rfl, rfl⟩
+      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
       exact ⟨_, rfl, le_sup_left⟩,
     le_sup_right := fun o₁ o₂ a ha => by
-      simp [map] at ha
-      rcases ha with ⟨b, rfl, c, rfl, rfl⟩
+      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
       exact ⟨_, rfl, le_sup_right⟩,
     sup_le := fun o₁ o₂ o₃ h₁ h₂ a ha => by
       cases ha

chore: fix most phantom #aligns (#1794)

3d3fb046

Diff

@@ -1290,7 +1290,7 @@ instance _root_.WithBot.trichotomous.gt [Preorder α] [h : IsTrichotomous α (·
 instance _root_.WithBot.isWellOrder.gt [Preorder α] [h : IsWellOrder α (· > ·)] :
     IsWellOrder (WithBot α) (· > ·) :=
   @WithTop.IsWellOrder.lt αᵒᵈ _ h
-#align with_top._root_.with_bot.is_well_order.gt WithBot.isWellOrder.gt
+#align with_bot.is_well_order.gt WithBot.isWellOrder.gt
 
 instance [LT α] [DenselyOrdered α] [NoMaxOrder α] : DenselyOrdered (WithTop α) :=
   OrderDual.denselyOrdered (WithBot αᵒᵈ)

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

93812b0f

Diff

@@ -9,6 +9,7 @@ Authors: Johannes Hölzl
 ! if you have ported upstream changes.
 -/
 import Mathlib.Order.BoundedOrder
+import Mathlib.Tactic.Lift
 
 /-!
 # `WithBot`, `WithTop`
@@ -173,6 +174,10 @@ theorem unbot_coe (x : α) (h : (x : WithBot α) ≠ ⊥ := coe_ne_bot) : (x : W
   rfl
 #align with_bot.unbot_coe WithBot.unbot_coe
 
+instance canLift : CanLift (WithBot α) α (↑) fun r => r ≠ ⊥ where
+  prf x h := ⟨x.unbot h, coe_unbot _ _⟩
+#align with_bot.can_lift WithBot.canLift
+
 section LE
 
 variable [LE α]
@@ -738,6 +743,10 @@ theorem untop_coe (x : α) (h : (x : WithTop α) ≠ ⊤ := coe_ne_top) : (x : W
   rfl
 #align with_top.untop_coe WithTop.untop_coe
 
+instance canLift : CanLift (WithTop α) α (↑) fun r => r ≠ ⊤ where
+  prf x h := ⟨x.untop h, coe_untop _ _⟩
+#align with_top.can_lift WithTop.canLift
+
 section LE
 
 variable [LE α]

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

@@ -88,7 +88,7 @@ theorem coe_ne_bot : (a : WithBot α) ≠ ⊥ :=
   fun.
 #align with_bot.coe_ne_bot WithBot.coe_ne_bot
 
-/-- Recursor for `with_bot` using the preferred forms `⊥` and `↑a`. -/
+/-- Recursor for `WithBot` using the preferred forms `⊥` and `↑a`. -/
 @[elab_as_elim]
 def recBotCoe {C : WithBot α → Sort _} (h₁ : C ⊥) (h₂ : ∀ a : α, C a) :
   ∀ n : WithBot α, C n
@@ -109,7 +109,7 @@ theorem recBotCoe_coe {C : WithBot α → Sort _} (d : C ⊥) (f : ∀ a : α, C
   rfl
 #align with_bot.rec_bot_coe_coe WithBot.recBotCoe_coe
 
-/-- Specialization of `option.get_or_else` to values in `with_bot α` that respects API boundaries.
+/-- Specialization of `Option.get_or_else` to values in `WithBot α` that respects API boundaries.
 -/
 def unbot' (d : α) (x : WithBot α) : α :=
   recBotCoe d id x
@@ -130,7 +130,7 @@ theorem coe_eq_coe : (a : WithBot α) = b ↔ a = b :=
   Option.some_inj
 #align with_bot.coe_eq_coe WithBot.coe_eq_coe
 
-/-- Lift a map `f : α → β` to `with_bot α → with_bot β`. Implemented using `option.map`. -/
+/-- Lift a map `f : α → β` to `WithBot α → WithBot β`. Implemented using `Option.map`. -/
 def map (f : α → β) : WithBot α → WithBot β :=
   Option.map f
 #align with_bot.map WithBot.map
@@ -155,7 +155,7 @@ theorem ne_bot_iff_exists {x : WithBot α} : x ≠ ⊥ ↔ ∃ a : α, ↑a = x
   Option.ne_none_iff_exists
 #align with_bot.ne_bot_iff_exists WithBot.ne_bot_iff_exists
 
-/-- Deconstruct a `x : with_bot α` to the underlying value in `α`, given a proof that `x ≠ ⊥`. -/
+/-- Deconstruct a `x : WithBot α` to the underlying value in `α`, given a proof that `x ≠ ⊥`. -/
 def unbot : ∀ x : WithBot α, x ≠ ⊥ → α
   | ⊥, h => absurd rfl h
   | Option.some x, _ => x
@@ -450,13 +450,13 @@ instance linearOrder [LinearOrder α] : LinearOrder (WithBot α) :=
   Lattice.toLinearOrder _
 #align with_bot.linear_order WithBot.linearOrder
 
--- this is not marked simp because the corresponding with_top lemmas are used
+-- this is not marked simp because the corresponding `WithTop` lemmas are used
 @[norm_cast]
 theorem coe_min [LinearOrder α] (x y : α) : ((min x y : α) : WithBot α) = min (x : WithBot α) y :=
   rfl
 #align with_bot.coe_min WithBot.coe_min
 
--- this is not marked simp because the corresponding with_top lemmas are used
+-- this is not marked simp because the corresponding `WithTop` lemmas are used
 @[norm_cast]
 theorem coe_max [LinearOrder α] (x y : α) : ((max x y : α) : WithBot α) = max (x : WithBot α) y :=
   rfl
@@ -525,7 +525,7 @@ instance noMaxOrder [LT α] [NoMaxOrder α] [Nonempty α] : NoMaxOrder (WithBot
 
 end WithBot
 
---TODO(Mario): Construct using order dual on with_bot
+--TODO(Mario): Construct using order dual on `WithBot`
 /-- Attach `⊤` to a type. -/
 def WithTop (α : Type _) :=
   Option α
@@ -580,7 +580,7 @@ theorem coe_ne_top : (a : WithTop α) ≠ ⊤ :=
   fun.
 #align with_top.coe_ne_top WithTop.coe_ne_top
 
-/-- Recursor for `with_top` using the preferred forms `⊤` and `↑a`. -/
+/-- Recursor for `WithTop` using the preferred forms `⊤` and `↑a`. -/
 @[elab_as_elim]
 def recTopCoe {C : WithTop α → Sort _} (h₁ : C ⊤) (h₂ : ∀ a : α, C a) : ∀ n : WithTop α, C n
 | none => h₁
@@ -613,15 +613,15 @@ protected def ofDual : WithTop αᵒᵈ ≃ WithBot α :=
   Equiv.refl _
 #align with_top.of_dual WithTop.ofDual
 
-/-- `with_bot.to_dual` is the equivalence sending `⊥` to `⊤` and any `a : α` to `to_dual a : αᵒᵈ`.
-See `with_bot.to_dual_top_equiv` for the related order-iso.
+/-- `WithBot.toDual` is the equivalence sending `⊥` to `⊤` and any `a : α` to `toDual a : αᵒᵈ`.
+See `WithBot.toDual_top_equiv` for the related order-iso.
 -/
 protected def _root_.WithBot.toDual : WithBot α ≃ WithTop αᵒᵈ :=
   Equiv.refl _
 #align with_bot.to_dual WithBot.toDual
 
-/-- `with_bot.of_dual` is the equivalence sending `⊥` to `⊤` and any `a : αᵒᵈ` to `of_dual a : α`.
-See `with_bot.to_dual_top_equiv` for the related order-iso.
+/-- `WithBot.ofDual` is the equivalence sending `⊥` to `⊤` and any `a : αᵒᵈ` to `ofDual a : α`.
+See `WithBot.ofDual_top_equiv` for the related order-iso.
 -/
 protected def _root_.WithBot.ofDual : WithBot αᵒᵈ ≃ WithTop α :=
   Equiv.refl _
@@ -659,7 +659,7 @@ theorem ofDual_apply_coe (a : αᵒᵈ) : WithTop.ofDual (a : WithTop αᵒᵈ)
   rfl
 #align with_top.of_dual_apply_coe WithTop.ofDual_apply_coe
 
-/-- Specialization of `option.get_or_else` to values in `with_top α` that respects API boundaries.
+/-- Specialization of `Option.get_or_else` to values in `WithTop α` that respects API boundaries.
 -/
 def untop' (d : α) (x : WithTop α) : α :=
   recTopCoe d id x
@@ -680,7 +680,7 @@ theorem coe_eq_coe : (a : WithTop α) = b ↔ a = b :=
   Option.some_inj
 #align with_top.coe_eq_coe WithTop.coe_eq_coe
 
-/-- Lift a map `f : α → β` to `with_top α → with_top β`. Implemented using `option.map`. -/
+/-- Lift a map `f : α → β` to `WithTop α → WithTop β`. Implemented using `Option.map`. -/
 def map (f : α → β) : WithTop α → WithTop β :=
   Option.map f
 #align with_top.map WithTop.map
@@ -723,7 +723,7 @@ theorem ne_top_iff_exists {x : WithTop α} : x ≠ ⊤ ↔ ∃ a : α, ↑a = x
   Option.ne_none_iff_exists
 #align with_top.ne_top_iff_exists WithTop.ne_top_iff_exists
 
-/-- Deconstruct a `x : with_top α` to the underlying value in `α`, given a proof that `x ≠ ⊤`. -/
+/-- Deconstruct a `x : WithTop α` to the underlying value in `α`, given a proof that `x ≠ ⊤`. -/
 def untop : ∀ x : WithTop α, x ≠ ⊤ → α :=
   WithBot.unbot
 #align with_top.untop WithTop.untop

chore: port order.basic again (#1112)

There seem to have been a number of changes since this was ported, and this takes the opportunity to restore the #aligns.

acffbef0

Diff

@@ -1284,7 +1284,7 @@ instance _root_.WithBot.isWellOrder.gt [Preorder α] [h : IsWellOrder α (· > 
 #align with_top._root_.with_bot.is_well_order.gt WithBot.isWellOrder.gt
 
 instance [LT α] [DenselyOrdered α] [NoMaxOrder α] : DenselyOrdered (WithTop α) :=
-  instDenselyOrderedOrderDualInstLTOrderDual (WithBot αᵒᵈ)
+  OrderDual.denselyOrdered (WithBot αᵒᵈ)
 
 theorem lt_iff_exists_coe_btwn [Preorder α] [DenselyOrdered α] [NoMaxOrder α] {a b : WithTop α} :
     a < b ↔ ∃ x : α, a < ↑x ∧ ↑x < b :=

chore: update lean4/std4 (#1096)

a9a1f7d7

Diff

@@ -777,8 +777,7 @@ theorem ofDual_le_ofDual_iff {a b : WithTop αᵒᵈ} : WithTop.ofDual a ≤ Wit
 
 @[simp, norm_cast]
 theorem coe_le_coe : (a : WithTop α) ≤ b ↔ a ≤ b := by
-  simp only [← toDual_le_toDual_iff, toDual_apply_coe, WithBot.coe_le_coe, toDual_le_toDual] ;
-  exact Iff.rfl
+  simp only [← toDual_le_toDual_iff, toDual_apply_coe, WithBot.coe_le_coe, toDual_le_toDual]
 #align with_top.coe_le_coe WithTop.coe_le_coe
 
 @[simp]
@@ -1006,8 +1005,7 @@ open OrderDual
 
 @[simp, norm_cast]
 theorem coe_lt_coe : (a : WithTop α) < b ↔ a < b := by
-  simp only [← toDual_lt_toDual_iff, toDual_apply_coe, WithBot.coe_lt_coe, toDual_lt_toDual] ;
-  exact Iff.rfl
+  simp only [← toDual_lt_toDual_iff, toDual_apply_coe, WithBot.coe_lt_coe, toDual_lt_toDual]
 #align with_top.coe_lt_coe WithTop.coe_lt_coe
 
 @[simp]