order.monotone.basic ⟷ Mathlib.Order.Monotone.Basic

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

@@ -1217,7 +1217,7 @@ theorem not_monotone_not_antitone_iff_exists_lt_lt :
     ¬Monotone f ∧ ¬Antitone f ↔
       ∃ a b c, a < b ∧ b < c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c) :=
   by
-  simp_rw [not_monotone_not_antitone_iff_exists_le_le, ← and_assoc']
+  simp_rw [not_monotone_not_antitone_iff_exists_le_le, ← and_assoc]
   refine'
         exists₃_congr fun a b c =>
           and_congr_left fun h => (Ne.le_iff_lt _).And <| Ne.le_iff_lt _ <;>

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

@@ -143,12 +143,12 @@ instance [i : Decidable (∀ a b, a ≤ b → f a ≤ f b)] : Decidable (Monoton
 instance [i : Decidable (∀ a b, a ≤ b → f b ≤ f a)] : Decidable (Antitone f) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a ≤ b → f a ≤ f b)] :
     Decidable (MonotoneOn f s) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a ≤ b → f b ≤ f a)] :
     Decidable (AntitoneOn f s) :=
   i
@@ -159,12 +159,12 @@ instance [i : Decidable (∀ a b, a < b → f a < f b)] : Decidable (StrictMono
 instance [i : Decidable (∀ a b, a < b → f b < f a)] : Decidable (StrictAnti f) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a < b → f a < f b)] :
     Decidable (StrictMonoOn f s) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a < b → f b < f a)] :
     Decidable (StrictAntiOn f s) :=
   i

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

@@ -1183,7 +1183,7 @@ theorem not_monotone_not_antitone_iff_exists_le_le :
     ¬Monotone f ∧ ¬Antitone f ↔
       ∃ a b c, a ≤ b ∧ b ≤ c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c) :=
   by
-  simp_rw [Monotone, Antitone, not_forall, not_le]
+  simp_rw [Monotone, Antitone, Classical.not_forall, not_le]
   refine' Iff.symm ⟨_, _⟩
   · rintro ⟨a, b, c, hab, hbc, ⟨hfab, hfcb⟩ | ⟨hfba, hfbc⟩⟩
     exacts [⟨⟨_, _, hbc, hfcb⟩, _, _, hab, hfab⟩, ⟨⟨_, _, hab, hfba⟩, _, _, hbc, hfbc⟩]

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

@@ -3,9 +3,9 @@ Copyright (c) 2014 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Mario Carneiro, Yaël Dillies
 -/
-import Mathbin.Order.Compare
-import Mathbin.Order.Max
-import Mathbin.Order.RelClasses
+import Order.Compare
+import Order.Max
+import Order.RelClasses
 
 #align_import order.monotone.basic from "leanprover-community/mathlib"@"554bb38de8ded0dafe93b7f18f0bfee6ef77dc5d"
 
@@ -143,12 +143,12 @@ instance [i : Decidable (∀ a b, a ≤ b → f a ≤ f b)] : Decidable (Monoton
 instance [i : Decidable (∀ a b, a ≤ b → f b ≤ f a)] : Decidable (Antitone f) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a ≤ b → f a ≤ f b)] :
     Decidable (MonotoneOn f s) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a ≤ b → f b ≤ f a)] :
     Decidable (AntitoneOn f s) :=
   i
@@ -159,12 +159,12 @@ instance [i : Decidable (∀ a b, a < b → f a < f b)] : Decidable (StrictMono
 instance [i : Decidable (∀ a b, a < b → f b < f a)] : Decidable (StrictAnti f) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a < b → f a < f b)] :
     Decidable (StrictMonoOn f s) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a < b → f b < f a)] :
     Decidable (StrictAntiOn f s) :=
   i

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

@@ -348,52 +348,52 @@ protected theorem StrictAntiOn.dual (hf : StrictAntiOn f s) :
 #align strict_anti_on.dual StrictAntiOn.dual
 -/
 
-alias antitone_comp_ofDual_iff ↔ _ Monotone.dual_left
+alias ⟨_, Monotone.dual_left⟩ := antitone_comp_ofDual_iff
 #align monotone.dual_left Monotone.dual_left
 
-alias monotone_comp_ofDual_iff ↔ _ Antitone.dual_left
+alias ⟨_, Antitone.dual_left⟩ := monotone_comp_ofDual_iff
 #align antitone.dual_left Antitone.dual_left
 
-alias antitone_toDual_comp_iff ↔ _ Monotone.dual_right
+alias ⟨_, Monotone.dual_right⟩ := antitone_toDual_comp_iff
 #align monotone.dual_right Monotone.dual_right
 
-alias monotone_toDual_comp_iff ↔ _ Antitone.dual_right
+alias ⟨_, Antitone.dual_right⟩ := monotone_toDual_comp_iff
 #align antitone.dual_right Antitone.dual_right
 
-alias antitoneOn_comp_ofDual_iff ↔ _ MonotoneOn.dual_left
+alias ⟨_, MonotoneOn.dual_left⟩ := antitoneOn_comp_ofDual_iff
 #align monotone_on.dual_left MonotoneOn.dual_left
 
-alias monotoneOn_comp_ofDual_iff ↔ _ AntitoneOn.dual_left
+alias ⟨_, AntitoneOn.dual_left⟩ := monotoneOn_comp_ofDual_iff
 #align antitone_on.dual_left AntitoneOn.dual_left
 
-alias antitoneOn_toDual_comp_iff ↔ _ MonotoneOn.dual_right
+alias ⟨_, MonotoneOn.dual_right⟩ := antitoneOn_toDual_comp_iff
 #align monotone_on.dual_right MonotoneOn.dual_right
 
-alias monotoneOn_toDual_comp_iff ↔ _ AntitoneOn.dual_right
+alias ⟨_, AntitoneOn.dual_right⟩ := monotoneOn_toDual_comp_iff
 #align antitone_on.dual_right AntitoneOn.dual_right
 
-alias strictAnti_comp_ofDual_iff ↔ _ StrictMono.dual_left
+alias ⟨_, StrictMono.dual_left⟩ := strictAnti_comp_ofDual_iff
 #align strict_mono.dual_left StrictMono.dual_left
 
-alias strictMono_comp_ofDual_iff ↔ _ StrictAnti.dual_left
+alias ⟨_, StrictAnti.dual_left⟩ := strictMono_comp_ofDual_iff
 #align strict_anti.dual_left StrictAnti.dual_left
 
-alias strictAnti_toDual_comp_iff ↔ _ StrictMono.dual_right
+alias ⟨_, StrictMono.dual_right⟩ := strictAnti_toDual_comp_iff
 #align strict_mono.dual_right StrictMono.dual_right
 
-alias strictMono_toDual_comp_iff ↔ _ StrictAnti.dual_right
+alias ⟨_, StrictAnti.dual_right⟩ := strictMono_toDual_comp_iff
 #align strict_anti.dual_right StrictAnti.dual_right
 
-alias strictAntiOn_comp_ofDual_iff ↔ _ StrictMonoOn.dual_left
+alias ⟨_, StrictMonoOn.dual_left⟩ := strictAntiOn_comp_ofDual_iff
 #align strict_mono_on.dual_left StrictMonoOn.dual_left
 
-alias strictMonoOn_comp_ofDual_iff ↔ _ StrictAntiOn.dual_left
+alias ⟨_, StrictAntiOn.dual_left⟩ := strictMonoOn_comp_ofDual_iff
 #align strict_anti_on.dual_left StrictAntiOn.dual_left
 
-alias strictAntiOn_toDual_comp_iff ↔ _ StrictMonoOn.dual_right
+alias ⟨_, StrictMonoOn.dual_right⟩ := strictAntiOn_toDual_comp_iff
 #align strict_mono_on.dual_right StrictMonoOn.dual_right
 
-alias strictMonoOn_toDual_comp_iff ↔ _ StrictAntiOn.dual_right
+alias ⟨_, StrictAntiOn.dual_right⟩ := strictMonoOn_toDual_comp_iff
 #align strict_anti_on.dual_right StrictAntiOn.dual_right
 
 end OrderDual

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

@@ -2,16 +2,13 @@
 Copyright (c) 2014 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Mario Carneiro, Yaël Dillies
-
-! This file was ported from Lean 3 source module order.monotone.basic
-! leanprover-community/mathlib commit 554bb38de8ded0dafe93b7f18f0bfee6ef77dc5d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Compare
 import Mathbin.Order.Max
 import Mathbin.Order.RelClasses
 
+#align_import order.monotone.basic from "leanprover-community/mathlib"@"554bb38de8ded0dafe93b7f18f0bfee6ef77dc5d"
+
 /-!
 # Monotonicity
 
@@ -146,12 +143,12 @@ instance [i : Decidable (∀ a b, a ≤ b → f a ≤ f b)] : Decidable (Monoton
 instance [i : Decidable (∀ a b, a ≤ b → f b ≤ f a)] : Decidable (Antitone f) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a ≤ b → f a ≤ f b)] :
     Decidable (MonotoneOn f s) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a ≤ b → f b ≤ f a)] :
     Decidable (AntitoneOn f s) :=
   i
@@ -162,12 +159,12 @@ instance [i : Decidable (∀ a b, a < b → f a < f b)] : Decidable (StrictMono
 instance [i : Decidable (∀ a b, a < b → f b < f a)] : Decidable (StrictAnti f) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a < b → f a < f b)] :
     Decidable (StrictMonoOn f s) :=
   i
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a < b → f b < f a)] :
     Decidable (StrictAntiOn f s) :=
   i

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Mario Carneiro, Yaël Dillies
 
 ! This file was ported from Lean 3 source module order.monotone.basic
-! leanprover-community/mathlib commit 90df25ded755a2cf9651ea850d1abe429b1e4eb1
+! leanprover-community/mathlib commit 554bb38de8ded0dafe93b7f18f0bfee6ef77dc5d
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -136,6 +136,44 @@ def StrictAntiOn (f : α → β) (s : Set α) : Prop :=
 
 end MonotoneDef
 
+section Decidable
+
+variable [Preorder α] [Preorder β] {f : α → β} {s : Set α}
+
+instance [i : Decidable (∀ a b, a ≤ b → f a ≤ f b)] : Decidable (Monotone f) :=
+  i
+
+instance [i : Decidable (∀ a b, a ≤ b → f b ≤ f a)] : Decidable (Antitone f) :=
+  i
+
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a ≤ b → f a ≤ f b)] :
+    Decidable (MonotoneOn f s) :=
+  i
+
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a ≤ b → f b ≤ f a)] :
+    Decidable (AntitoneOn f s) :=
+  i
+
+instance [i : Decidable (∀ a b, a < b → f a < f b)] : Decidable (StrictMono f) :=
+  i
+
+instance [i : Decidable (∀ a b, a < b → f b < f a)] : Decidable (StrictAnti f) :=
+  i
+
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a < b → f a < f b)] :
+    Decidable (StrictMonoOn f s) :=
+  i
+
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+instance [i : Decidable (∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a < b → f b < f a)] :
+    Decidable (StrictAntiOn f s) :=
+  i
+
+end Decidable
+
 /-! ### Monotonicity on the dual order
 
 Strictly, many of the `*_on.dual` lemmas in this section should use `of_dual ⁻¹' s` instead of `s`,

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

@@ -1348,26 +1348,35 @@ theorem Int.rel_of_forall_rel_succ_of_le (r : β → β → Prop) [IsRefl β r]
 #align int.rel_of_forall_rel_succ_of_le Int.rel_of_forall_rel_succ_of_le
 -/
 
+#print monotone_int_of_le_succ /-
 theorem monotone_int_of_le_succ {f : ℤ → α} (hf : ∀ n, f n ≤ f (n + 1)) : Monotone f :=
   Int.rel_of_forall_rel_succ_of_le (· ≤ ·) hf
 #align monotone_int_of_le_succ monotone_int_of_le_succ
+-/
 
+#print antitone_int_of_succ_le /-
 theorem antitone_int_of_succ_le {f : ℤ → α} (hf : ∀ n, f (n + 1) ≤ f n) : Antitone f :=
   Int.rel_of_forall_rel_succ_of_le (· ≥ ·) hf
 #align antitone_int_of_succ_le antitone_int_of_succ_le
+-/
 
+#print strictMono_int_of_lt_succ /-
 theorem strictMono_int_of_lt_succ {f : ℤ → α} (hf : ∀ n, f n < f (n + 1)) : StrictMono f :=
   Int.rel_of_forall_rel_succ_of_lt (· < ·) hf
 #align strict_mono_int_of_lt_succ strictMono_int_of_lt_succ
+-/
 
+#print strictAnti_int_of_succ_lt /-
 theorem strictAnti_int_of_succ_lt {f : ℤ → α} (hf : ∀ n, f (n + 1) < f n) : StrictAnti f :=
   Int.rel_of_forall_rel_succ_of_lt (· > ·) hf
 #align strict_anti_int_of_succ_lt strictAnti_int_of_succ_lt
+-/
 
 namespace Int
 
 variable (α) [Nonempty α] [NoMinOrder α] [NoMaxOrder α]
 
+#print Int.exists_strictMono /-
 /-- If `α` is a nonempty preorder with no minimal or maximal elements, then there exists a strictly
 monotone function `f : ℤ → α`. -/
 theorem exists_strictMono : ∃ f : ℤ → α, StrictMono f :=
@@ -1383,12 +1392,15 @@ theorem exists_strictMono : ∃ f : ℤ → α, StrictMono f :=
     exact hg Nat.zero_lt_one
   · exact hg (Nat.lt_succ_self _)
 #align int.exists_strict_mono Int.exists_strictMono
+-/
 
+#print Int.exists_strictAnti /-
 /-- If `α` is a nonempty preorder with no minimal or maximal elements, then there exists a strictly
 antitone function `f : ℤ → α`. -/
 theorem exists_strictAnti : ∃ f : ℤ → α, StrictAnti f :=
   exists_strictMono αᵒᵈ
 #align int.exists_strict_anti Int.exists_strictAnti
+-/
 
 end Int
 
@@ -1411,19 +1423,23 @@ theorem Antitone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Antitone f) (n : ℕ)
 #align antitone.ne_of_lt_of_lt_nat Antitone.ne_of_lt_of_lt_nat
 -/
 
+#print Monotone.ne_of_lt_of_lt_int /-
 /-- If `f` is a monotone function from `ℤ` to a preorder and `x` lies between `f n` and
   `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/
 theorem Monotone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Monotone f) (n : ℤ) {x : α} (h1 : f n < x)
     (h2 : x < f (n + 1)) (a : ℤ) : f a ≠ x := by rintro rfl;
   exact (hf.reflect_lt h1).not_le (Int.le_of_lt_add_one <| hf.reflect_lt h2)
 #align monotone.ne_of_lt_of_lt_int Monotone.ne_of_lt_of_lt_int
+-/
 
+#print Antitone.ne_of_lt_of_lt_int /-
 /-- If `f` is an antitone function from `ℤ` to a preorder and `x` lies between `f (n + 1)` and
 `f n`, then `x` doesn't lie in the range of `f`. -/
 theorem Antitone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Antitone f) (n : ℤ) {x : α}
     (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℤ) : f a ≠ x := by rintro rfl;
   exact (hf.reflect_lt h2).not_le (Int.le_of_lt_add_one <| hf.reflect_lt h1)
 #align antitone.ne_of_lt_of_lt_int Antitone.ne_of_lt_of_lt_int
+-/
 
 #print StrictMono.id_le /-
 theorem StrictMono.id_le {φ : ℕ → ℕ} (h : StrictMono φ) : ∀ n, n ≤ φ n := fun n =>
@@ -1448,19 +1464,27 @@ section Preorder
 
 variable [Preorder α] [Preorder β] [Preorder γ] [Preorder δ] {f : α → γ} {g : β → δ} {a b : α}
 
+#print monotone_fst /-
 theorem monotone_fst : Monotone (@Prod.fst α β) := fun a b => And.left
 #align monotone_fst monotone_fst
+-/
 
+#print monotone_snd /-
 theorem monotone_snd : Monotone (@Prod.snd α β) := fun a b => And.right
 #align monotone_snd monotone_snd
+-/
 
+#print Monotone.prod_map /-
 theorem Monotone.prod_map (hf : Monotone f) (hg : Monotone g) : Monotone (Prod.map f g) :=
   fun a b h => ⟨hf h.1, hg h.2⟩
 #align monotone.prod_map Monotone.prod_map
+-/
 
+#print Antitone.prod_map /-
 theorem Antitone.prod_map (hf : Antitone f) (hg : Antitone g) : Antitone (Prod.map f g) :=
   fun a b h => ⟨hf h.1, hg h.2⟩
 #align antitone.prod_map Antitone.prod_map
+-/
 
 end Preorder
 
@@ -1468,17 +1492,21 @@ section PartialOrder
 
 variable [PartialOrder α] [PartialOrder β] [Preorder γ] [Preorder δ] {f : α → γ} {g : β → δ}
 
+#print StrictMono.prod_map /-
 theorem StrictMono.prod_map (hf : StrictMono f) (hg : StrictMono g) : StrictMono (Prod.map f g) :=
   fun a b => by
   simp_rw [Prod.lt_iff]
   exact Or.imp (And.imp hf.imp hg.monotone.imp) (And.imp hf.monotone.imp hg.imp)
 #align strict_mono.prod_map StrictMono.prod_map
+-/
 
+#print StrictAnti.prod_map /-
 theorem StrictAnti.prod_map (hf : StrictAnti f) (hg : StrictAnti g) : StrictAnti (Prod.map f g) :=
   fun a b => by
   simp_rw [Prod.lt_iff]
   exact Or.imp (And.imp hf.imp hg.antitone.imp) (And.imp hf.antitone.imp hg.imp)
 #align strict_anti.prod_map StrictAnti.prod_map
+-/
 
 end PartialOrder
 

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

@@ -700,7 +700,7 @@ theorem injective_of_lt_imp_ne [LinearOrder α] {f : α → β} (h : ∀ x y, x
   intro x y hxy
   contrapose hxy
   cases' Ne.lt_or_lt hxy with hxy hxy
-  exacts[h _ _ hxy, (h _ _ hxy).symm]
+  exacts [h _ _ hxy, (h _ _ hxy).symm]
 #align injective_of_lt_imp_ne injective_of_lt_imp_ne
 -/
 
@@ -1151,7 +1151,7 @@ theorem not_monotone_not_antitone_iff_exists_le_le :
   simp_rw [Monotone, Antitone, not_forall, not_le]
   refine' Iff.symm ⟨_, _⟩
   · rintro ⟨a, b, c, hab, hbc, ⟨hfab, hfcb⟩ | ⟨hfba, hfbc⟩⟩
-    exacts[⟨⟨_, _, hbc, hfcb⟩, _, _, hab, hfab⟩, ⟨⟨_, _, hab, hfba⟩, _, _, hbc, hfbc⟩]
+    exacts [⟨⟨_, _, hbc, hfcb⟩, _, _, hab, hfab⟩, ⟨⟨_, _, hab, hfba⟩, _, _, hbc, hfbc⟩]
   rintro ⟨⟨a, b, hab, hfba⟩, c, d, hcd, hfcd⟩
   obtain hda | had := le_total d a
   · obtain hfad | hfda := le_total (f a) (f d)
@@ -1236,7 +1236,7 @@ theorem Nat.rel_of_forall_rel_succ_of_le_of_lt (r : β → β → Prop) [IsTrans
     (h : ∀ n, a ≤ n → r (f n) (f (n + 1))) ⦃b c : ℕ⦄ (hab : a ≤ b) (hbc : b < c) : r (f b) (f c) :=
   by
   induction' hbc with k b_lt_k r_b_k
-  exacts[h _ hab, trans r_b_k (h _ (hab.trans_lt b_lt_k).le)]
+  exacts [h _ hab, trans r_b_k (h _ (hab.trans_lt b_lt_k).le)]
 #align nat.rel_of_forall_rel_succ_of_le_of_lt Nat.rel_of_forall_rel_succ_of_le_of_lt
 -/
 

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

@@ -370,9 +370,11 @@ section Preorder
 
 variable [Preorder α]
 
+#print Monotone.comp_le_comp_left /-
 theorem Monotone.comp_le_comp_left [Preorder β] {f : β → α} {g h : γ → β} (hf : Monotone f)
     (le_gh : g ≤ h) : LE.le.{max w u} (f ∘ g) (f ∘ h) := fun x => hf (le_gh x)
 #align monotone.comp_le_comp_left Monotone.comp_le_comp_left
+-/
 
 variable [Preorder γ]
 
@@ -426,21 +428,29 @@ However if you find yourself writing `hf.imp h`, then you should have written `h
 -/
 
 
+#print Monotone.imp /-
 theorem Monotone.imp (hf : Monotone f) (h : a ≤ b) : f a ≤ f b :=
   hf h
 #align monotone.imp Monotone.imp
+-/
 
+#print Antitone.imp /-
 theorem Antitone.imp (hf : Antitone f) (h : a ≤ b) : f b ≤ f a :=
   hf h
 #align antitone.imp Antitone.imp
+-/
 
+#print StrictMono.imp /-
 theorem StrictMono.imp (hf : StrictMono f) (h : a < b) : f a < f b :=
   hf h
 #align strict_mono.imp StrictMono.imp
+-/
 
+#print StrictAnti.imp /-
 theorem StrictAnti.imp (hf : StrictAnti f) (h : a < b) : f b < f a :=
   hf h
 #align strict_anti.imp StrictAnti.imp
+-/
 
 #print Monotone.monotoneOn /-
 protected theorem Monotone.monotoneOn (hf : Monotone f) (s : Set α) : MonotoneOn f s :=
@@ -520,27 +530,35 @@ section PartialOrder
 
 variable [PartialOrder α] [Preorder β] {f : α → β} {s : Set α}
 
+#print monotone_iff_forall_lt /-
 theorem monotone_iff_forall_lt : Monotone f ↔ ∀ ⦃a b⦄, a < b → f a ≤ f b :=
   forall₂_congr fun a b =>
     ⟨fun hf h => hf h.le, fun hf h => h.eq_or_lt.elim (fun H => (congr_arg _ H).le) hf⟩
 #align monotone_iff_forall_lt monotone_iff_forall_lt
+-/
 
+#print antitone_iff_forall_lt /-
 theorem antitone_iff_forall_lt : Antitone f ↔ ∀ ⦃a b⦄, a < b → f b ≤ f a :=
   forall₂_congr fun a b =>
     ⟨fun hf h => hf h.le, fun hf h => h.eq_or_lt.elim (fun H => (congr_arg _ H).ge) hf⟩
 #align antitone_iff_forall_lt antitone_iff_forall_lt
+-/
 
+#print monotoneOn_iff_forall_lt /-
 theorem monotoneOn_iff_forall_lt :
     MonotoneOn f s ↔ ∀ ⦃a⦄ (ha : a ∈ s) ⦃b⦄ (hb : b ∈ s), a < b → f a ≤ f b :=
   ⟨fun hf a ha b hb h => hf ha hb h.le, fun hf a ha b hb h =>
     h.eq_or_lt.elim (fun H => (congr_arg _ H).le) (hf ha hb)⟩
 #align monotone_on_iff_forall_lt monotoneOn_iff_forall_lt
+-/
 
+#print antitoneOn_iff_forall_lt /-
 theorem antitoneOn_iff_forall_lt :
     AntitoneOn f s ↔ ∀ ⦃a⦄ (ha : a ∈ s) ⦃b⦄ (hb : b ∈ s), a < b → f b ≤ f a :=
   ⟨fun hf a ha b hb h => hf ha hb h.le, fun hf a ha b hb h =>
     h.eq_or_lt.elim (fun H => (congr_arg _ H).ge) (hf ha hb)⟩
 #align antitone_on_iff_forall_lt antitoneOn_iff_forall_lt
+-/
 
 #print StrictMonoOn.monotoneOn /-
 -- `preorder α` isn't strong enough: if the preorder on `α` is an equivalence relation,
@@ -662,16 +680,21 @@ theorem antitoneOn_const [Preorder α] [Preorder β] {c : β} {s : Set α} :
 #align antitone_on_const antitoneOn_const
 -/
 
+#print strictMono_of_le_iff_le /-
 theorem strictMono_of_le_iff_le [Preorder α] [Preorder β] {f : α → β}
     (h : ∀ x y, x ≤ y ↔ f x ≤ f y) : StrictMono f := fun a b =>
   (lt_iff_lt_of_le_iff_le' (h _ _) (h _ _)).1
 #align strict_mono_of_le_iff_le strictMono_of_le_iff_le
+-/
 
+#print strictAnti_of_le_iff_le /-
 theorem strictAnti_of_le_iff_le [Preorder α] [Preorder β] {f : α → β}
     (h : ∀ x y, x ≤ y ↔ f y ≤ f x) : StrictAnti f := fun a b =>
   (lt_iff_lt_of_le_iff_le' (h _ _) (h _ _)).1
 #align strict_anti_of_le_iff_le strictAnti_of_le_iff_le
+-/
 
+#print injective_of_lt_imp_ne /-
 theorem injective_of_lt_imp_ne [LinearOrder α] {f : α → β} (h : ∀ x y, x < y → f x ≠ f y) :
     Injective f := by
   intro x y hxy
@@ -679,39 +702,51 @@ theorem injective_of_lt_imp_ne [LinearOrder α] {f : α → β} (h : ∀ x y, x
   cases' Ne.lt_or_lt hxy with hxy hxy
   exacts[h _ _ hxy, (h _ _ hxy).symm]
 #align injective_of_lt_imp_ne injective_of_lt_imp_ne
+-/
 
+#print injective_of_le_imp_le /-
 theorem injective_of_le_imp_le [PartialOrder α] [Preorder β] (f : α → β)
     (h : ∀ {x y}, f x ≤ f y → x ≤ y) : Injective f := fun x y hxy => (h hxy.le).antisymm (h hxy.ge)
 #align injective_of_le_imp_le injective_of_le_imp_le
+-/
 
 section Preorder
 
 variable [Preorder α] [Preorder β] {f g : α → β} {a : α}
 
+#print StrictMono.isMax_of_apply /-
 theorem StrictMono.isMax_of_apply (hf : StrictMono f) (ha : IsMax (f a)) : IsMax a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMax_iff.1 h
     (hf hb).not_isMax ha
 #align strict_mono.is_max_of_apply StrictMono.isMax_of_apply
+-/
 
+#print StrictMono.isMin_of_apply /-
 theorem StrictMono.isMin_of_apply (hf : StrictMono f) (ha : IsMin (f a)) : IsMin a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMin_iff.1 h
     (hf hb).not_isMin ha
 #align strict_mono.is_min_of_apply StrictMono.isMin_of_apply
+-/
 
+#print StrictAnti.isMax_of_apply /-
 theorem StrictAnti.isMax_of_apply (hf : StrictAnti f) (ha : IsMin (f a)) : IsMax a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMax_iff.1 h
     (hf hb).not_isMin ha
 #align strict_anti.is_max_of_apply StrictAnti.isMax_of_apply
+-/
 
+#print StrictAnti.isMin_of_apply /-
 theorem StrictAnti.isMin_of_apply (hf : StrictAnti f) (ha : IsMax (f a)) : IsMin a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMin_iff.1 h
     (hf hb).not_isMax ha
 #align strict_anti.is_min_of_apply StrictAnti.isMin_of_apply
+-/
 
+#print StrictMono.ite' /-
 protected theorem StrictMono.ite' (hf : StrictMono f) (hg : StrictMono g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x)
     (hfg : ∀ ⦃x y⦄, p x → ¬p y → x < y → f x < g y) :
@@ -725,25 +760,32 @@ protected theorem StrictMono.ite' (hf : StrictMono f) (hg : StrictMono g) {p : 
   · simpa [hx, hy] using hfg hx hy h
   · simpa [hx, hy] using hg h
 #align strict_mono.ite' StrictMono.ite'
+-/
 
+#print StrictMono.ite /-
 protected theorem StrictMono.ite (hf : StrictMono f) (hg : StrictMono g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x) (hfg : ∀ x, f x ≤ g x) :
     StrictMono fun x => if p x then f x else g x :=
   hf.ite' hg hp fun x y hx hy h => (hf h).trans_le (hfg y)
 #align strict_mono.ite StrictMono.ite
+-/
 
+#print StrictAnti.ite' /-
 protected theorem StrictAnti.ite' (hf : StrictAnti f) (hg : StrictAnti g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x)
     (hfg : ∀ ⦃x y⦄, p x → ¬p y → x < y → g y < f x) :
     StrictAnti fun x => if p x then f x else g x :=
   (StrictMono.ite' hf.dual_right hg.dual_right hp hfg).dual_right
 #align strict_anti.ite' StrictAnti.ite'
+-/
 
+#print StrictAnti.ite /-
 protected theorem StrictAnti.ite (hf : StrictAnti f) (hg : StrictAnti g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x) (hfg : ∀ x, g x ≤ f x) :
     StrictAnti fun x => if p x then f x else g x :=
   hf.ite' hg hp fun x y hx hy h => (hfg y).trans_lt (hf h)
 #align strict_anti.ite StrictAnti.ite
+-/
 
 end Preorder
 
@@ -911,34 +953,46 @@ variable [Preorder β] {f : α → β} {s : Set α}
 
 open Ordering
 
+#print Monotone.reflect_lt /-
 theorem Monotone.reflect_lt (hf : Monotone f) {a b : α} (h : f a < f b) : a < b :=
   lt_of_not_ge fun h' => h.not_le (hf h')
 #align monotone.reflect_lt Monotone.reflect_lt
+-/
 
+#print Antitone.reflect_lt /-
 theorem Antitone.reflect_lt (hf : Antitone f) {a b : α} (h : f a < f b) : b < a :=
   lt_of_not_ge fun h' => h.not_le (hf h')
 #align antitone.reflect_lt Antitone.reflect_lt
+-/
 
+#print MonotoneOn.reflect_lt /-
 theorem MonotoneOn.reflect_lt (hf : MonotoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
     (h : f a < f b) : a < b :=
   lt_of_not_ge fun h' => h.not_le <| hf hb ha h'
 #align monotone_on.reflect_lt MonotoneOn.reflect_lt
+-/
 
+#print AntitoneOn.reflect_lt /-
 theorem AntitoneOn.reflect_lt (hf : AntitoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
     (h : f a < f b) : b < a :=
   lt_of_not_ge fun h' => h.not_le <| hf ha hb h'
 #align antitone_on.reflect_lt AntitoneOn.reflect_lt
+-/
 
+#print StrictMonoOn.le_iff_le /-
 theorem StrictMonoOn.le_iff_le (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a ≤ f b ↔ a ≤ b :=
   ⟨fun h => le_of_not_gt fun h' => (hf hb ha h').not_le h, fun h =>
     h.lt_or_eq_dec.elim (fun h' => (hf ha hb h').le) fun h' => h' ▸ le_rfl⟩
 #align strict_mono_on.le_iff_le StrictMonoOn.le_iff_le
+-/
 
+#print StrictAntiOn.le_iff_le /-
 theorem StrictAntiOn.le_iff_le (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a ≤ f b ↔ b ≤ a :=
   hf.dual_right.le_iff_le hb ha
 #align strict_anti_on.le_iff_le StrictAntiOn.le_iff_le
+-/
 
 #print StrictMonoOn.eq_iff_eq /-
 theorem StrictMonoOn.eq_iff_eq (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
@@ -955,32 +1009,45 @@ theorem StrictAntiOn.eq_iff_eq (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s)
 #align strict_anti_on.eq_iff_eq StrictAntiOn.eq_iff_eq
 -/
 
+#print StrictMonoOn.lt_iff_lt /-
 theorem StrictMonoOn.lt_iff_lt (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a < f b ↔ a < b := by
   rw [lt_iff_le_not_le, lt_iff_le_not_le, hf.le_iff_le ha hb, hf.le_iff_le hb ha]
 #align strict_mono_on.lt_iff_lt StrictMonoOn.lt_iff_lt
+-/
 
+#print StrictAntiOn.lt_iff_lt /-
 theorem StrictAntiOn.lt_iff_lt (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a < f b ↔ b < a :=
   hf.dual_right.lt_iff_lt hb ha
 #align strict_anti_on.lt_iff_lt StrictAntiOn.lt_iff_lt
+-/
 
+#print StrictMono.le_iff_le /-
 theorem StrictMono.le_iff_le (hf : StrictMono f) {a b : α} : f a ≤ f b ↔ a ≤ b :=
   (hf.StrictMonoOn Set.univ).le_iff_le trivial trivial
 #align strict_mono.le_iff_le StrictMono.le_iff_le
+-/
 
+#print StrictAnti.le_iff_le /-
 theorem StrictAnti.le_iff_le (hf : StrictAnti f) {a b : α} : f a ≤ f b ↔ b ≤ a :=
   (hf.StrictAntiOn Set.univ).le_iff_le trivial trivial
 #align strict_anti.le_iff_le StrictAnti.le_iff_le
+-/
 
+#print StrictMono.lt_iff_lt /-
 theorem StrictMono.lt_iff_lt (hf : StrictMono f) {a b : α} : f a < f b ↔ a < b :=
   (hf.StrictMonoOn Set.univ).lt_iff_lt trivial trivial
 #align strict_mono.lt_iff_lt StrictMono.lt_iff_lt
+-/
 
+#print StrictAnti.lt_iff_lt /-
 theorem StrictAnti.lt_iff_lt (hf : StrictAnti f) {a b : α} : f a < f b ↔ b < a :=
   (hf.StrictAntiOn Set.univ).lt_iff_lt trivial trivial
 #align strict_anti.lt_iff_lt StrictAnti.lt_iff_lt
+-/
 
+#print StrictMonoOn.compares /-
 protected theorem StrictMonoOn.compares (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s)
     (hb : b ∈ s) : ∀ {o : Ordering}, o.Compares (f a) (f b) ↔ o.Compares a b
   | Ordering.lt => hf.lt_iff_lt ha hb
@@ -989,21 +1056,28 @@ protected theorem StrictMonoOn.compares (hf : StrictMonoOn f s) {a b : α} (ha :
       congr_arg _⟩
   | Ordering.gt => hf.lt_iff_lt hb ha
 #align strict_mono_on.compares StrictMonoOn.compares
+-/
 
+#print StrictAntiOn.compares /-
 protected theorem StrictAntiOn.compares (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
     {o : Ordering} : o.Compares (f a) (f b) ↔ o.Compares b a :=
   toDual_compares_toDual.trans <| hf.dual_right.Compares hb ha
 #align strict_anti_on.compares StrictAntiOn.compares
+-/
 
+#print StrictMono.compares /-
 protected theorem StrictMono.compares (hf : StrictMono f) {a b : α} {o : Ordering} :
     o.Compares (f a) (f b) ↔ o.Compares a b :=
   (hf.StrictMonoOn Set.univ).Compares trivial trivial
 #align strict_mono.compares StrictMono.compares
+-/
 
+#print StrictAnti.compares /-
 protected theorem StrictAnti.compares (hf : StrictAnti f) {a b : α} {o : Ordering} :
     o.Compares (f a) (f b) ↔ o.Compares b a :=
   (hf.StrictAntiOn Set.univ).Compares trivial trivial
 #align strict_anti.compares StrictAnti.compares
+-/
 
 #print StrictMono.injective /-
 theorem StrictMono.injective (hf : StrictMono f) : Injective f := fun x y h =>
@@ -1017,25 +1091,33 @@ theorem StrictAnti.injective (hf : StrictAnti f) : Injective f := fun x y h =>
 #align strict_anti.injective StrictAnti.injective
 -/
 
+#print StrictMono.maximal_of_maximal_image /-
 theorem StrictMono.maximal_of_maximal_image (hf : StrictMono f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
     x ≤ a :=
   hf.le_iff_le.mp (hmax (f x))
 #align strict_mono.maximal_of_maximal_image StrictMono.maximal_of_maximal_image
+-/
 
+#print StrictMono.minimal_of_minimal_image /-
 theorem StrictMono.minimal_of_minimal_image (hf : StrictMono f) {a} (hmin : ∀ p, f a ≤ p) (x : α) :
     a ≤ x :=
   hf.le_iff_le.mp (hmin (f x))
 #align strict_mono.minimal_of_minimal_image StrictMono.minimal_of_minimal_image
+-/
 
+#print StrictAnti.minimal_of_maximal_image /-
 theorem StrictAnti.minimal_of_maximal_image (hf : StrictAnti f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
     a ≤ x :=
   hf.le_iff_le.mp (hmax (f x))
 #align strict_anti.minimal_of_maximal_image StrictAnti.minimal_of_maximal_image
+-/
 
+#print StrictAnti.maximal_of_minimal_image /-
 theorem StrictAnti.maximal_of_minimal_image (hf : StrictAnti f) {a} (hmin : ∀ p, f a ≤ p) (x : α) :
     x ≤ a :=
   hf.le_iff_le.mp (hmin (f x))
 #align strict_anti.maximal_of_minimal_image StrictAnti.maximal_of_minimal_image
+-/
 
 end Preorder
 
@@ -1059,6 +1141,7 @@ end PartialOrder
 
 variable [LinearOrder β] {f : α → β} {s : Set α} {x y : α}
 
+#print not_monotone_not_antitone_iff_exists_le_le /-
 /-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
 downright. -/
 theorem not_monotone_not_antitone_iff_exists_le_le :
@@ -1090,7 +1173,9 @@ theorem not_monotone_not_antitone_iff_exists_le_le :
     · exact ⟨a, b, d, hab, hbd, Or.inr ⟨hfba, hfbd⟩⟩
     · exact ⟨a, d, b, had, hdb, Or.inl ⟨hfac.trans_lt hfcd, hfbd⟩⟩
 #align not_monotone_not_antitone_iff_exists_le_le not_monotone_not_antitone_iff_exists_le_le
+-/
 
+#print not_monotone_not_antitone_iff_exists_lt_lt /-
 /-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
 downright. -/
 theorem not_monotone_not_antitone_iff_exists_lt_lt :
@@ -1104,6 +1189,7 @@ theorem not_monotone_not_antitone_iff_exists_lt_lt :
       rintro rfl <;>
     simpa using h
 #align not_monotone_not_antitone_iff_exists_lt_lt not_monotone_not_antitone_iff_exists_lt_lt
+-/
 
 /-!
 ### Strictly monotone functions and `cmp`
@@ -1176,24 +1262,33 @@ theorem Nat.rel_of_forall_rel_succ_of_le (r : β → β → Prop) [IsRefl β r]
 #align nat.rel_of_forall_rel_succ_of_le Nat.rel_of_forall_rel_succ_of_le
 -/
 
+#print monotone_nat_of_le_succ /-
 theorem monotone_nat_of_le_succ {f : ℕ → α} (hf : ∀ n, f n ≤ f (n + 1)) : Monotone f :=
   Nat.rel_of_forall_rel_succ_of_le (· ≤ ·) hf
 #align monotone_nat_of_le_succ monotone_nat_of_le_succ
+-/
 
+#print antitone_nat_of_succ_le /-
 theorem antitone_nat_of_succ_le {f : ℕ → α} (hf : ∀ n, f (n + 1) ≤ f n) : Antitone f :=
   @monotone_nat_of_le_succ αᵒᵈ _ _ hf
 #align antitone_nat_of_succ_le antitone_nat_of_succ_le
+-/
 
+#print strictMono_nat_of_lt_succ /-
 theorem strictMono_nat_of_lt_succ {f : ℕ → α} (hf : ∀ n, f n < f (n + 1)) : StrictMono f :=
   Nat.rel_of_forall_rel_succ_of_lt (· < ·) hf
 #align strict_mono_nat_of_lt_succ strictMono_nat_of_lt_succ
+-/
 
+#print strictAnti_nat_of_succ_lt /-
 theorem strictAnti_nat_of_succ_lt {f : ℕ → α} (hf : ∀ n, f (n + 1) < f n) : StrictAnti f :=
   @strictMono_nat_of_lt_succ αᵒᵈ _ f hf
 #align strict_anti_nat_of_succ_lt strictAnti_nat_of_succ_lt
+-/
 
 namespace Nat
 
+#print Nat.exists_strictMono' /-
 /-- If `α` is a preorder with no maximal elements, then there exists a strictly monotone function
 `ℕ → α` with any prescribed value of `f 0`. -/
 theorem exists_strictMono' [NoMaxOrder α] (a : α) : ∃ f : ℕ → α, StrictMono f ∧ f 0 = a :=
@@ -1202,15 +1297,19 @@ theorem exists_strictMono' [NoMaxOrder α] (a : α) : ∃ f : ℕ → α, Strict
   choose g hg
   exact ⟨fun n => Nat.recOn n a fun _ => g, strictMono_nat_of_lt_succ fun n => hg _, rfl⟩
 #align nat.exists_strict_mono' Nat.exists_strictMono'
+-/
 
+#print Nat.exists_strictAnti' /-
 /-- If `α` is a preorder with no maximal elements, then there exists a strictly antitone function
 `ℕ → α` with any prescribed value of `f 0`. -/
 theorem exists_strictAnti' [NoMinOrder α] (a : α) : ∃ f : ℕ → α, StrictAnti f ∧ f 0 = a :=
   exists_strictMono' (OrderDual.toDual a)
 #align nat.exists_strict_anti' Nat.exists_strictAnti'
+-/
 
 variable (α)
 
+#print Nat.exists_strictMono /-
 /-- If `α` is a nonempty preorder with no maximal elements, then there exists a strictly monotone
 function `ℕ → α`. -/
 theorem exists_strictMono [Nonempty α] [NoMaxOrder α] : ∃ f : ℕ → α, StrictMono f :=
@@ -1218,12 +1317,15 @@ theorem exists_strictMono [Nonempty α] [NoMaxOrder α] : ∃ f : ℕ → α, St
   let ⟨f, hf, hfa⟩ := exists_strictMono' a
   ⟨f, hf⟩
 #align nat.exists_strict_mono Nat.exists_strictMono
+-/
 
+#print Nat.exists_strictAnti /-
 /-- If `α` is a nonempty preorder with no minimal elements, then there exists a strictly antitone
 function `ℕ → α`. -/
 theorem exists_strictAnti [Nonempty α] [NoMinOrder α] : ∃ f : ℕ → α, StrictAnti f :=
   exists_strictMono αᵒᵈ
 #align nat.exists_strict_anti Nat.exists_strictAnti
+-/
 
 end Nat
 
@@ -1290,6 +1392,7 @@ theorem exists_strictAnti : ∃ f : ℤ → α, StrictAnti f :=
 
 end Int
 
+#print Monotone.ne_of_lt_of_lt_nat /-
 -- TODO@Yael: Generalize the following four to succ orders
 /-- If `f` is a monotone function from `ℕ` to a preorder such that `x` lies between `f n` and
   `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/
@@ -1297,13 +1400,16 @@ theorem Monotone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Monotone f) (n : ℕ)
     (h2 : x < f (n + 1)) (a : ℕ) : f a ≠ x := by rintro rfl;
   exact (hf.reflect_lt h1).not_le (Nat.le_of_lt_succ <| hf.reflect_lt h2)
 #align monotone.ne_of_lt_of_lt_nat Monotone.ne_of_lt_of_lt_nat
+-/
 
+#print Antitone.ne_of_lt_of_lt_nat /-
 /-- If `f` is an antitone function from `ℕ` to a preorder such that `x` lies between `f (n + 1)` and
 `f n`, then `x` doesn't lie in the range of `f`. -/
 theorem Antitone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Antitone f) (n : ℕ) {x : α}
     (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℕ) : f a ≠ x := by rintro rfl;
   exact (hf.reflect_lt h2).not_le (Nat.le_of_lt_succ <| hf.reflect_lt h1)
 #align antitone.ne_of_lt_of_lt_nat Antitone.ne_of_lt_of_lt_nat
+-/
 
 /-- If `f` is a monotone function from `ℤ` to a preorder and `x` lies between `f n` and
   `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/

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

@@ -370,12 +370,6 @@ section Preorder
 
 variable [Preorder α]
 
-/- warning: monotone.comp_le_comp_left -> Monotone.comp_le_comp_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : β -> α} {g : γ -> β} {h : γ -> β}, (Monotone.{u2, u1} β α _inst_2 _inst_1 f) -> (LE.le.{max u3 u2} (γ -> β) (Pi.hasLe.{u3, u2} γ (fun (ᾰ : γ) => β) (fun (i : γ) => Preorder.toHasLe.{u2} β _inst_2)) g h) -> (LE.le.{max u3 u1} (γ -> α) (Pi.hasLe.{u3, u1} γ (fun (ᾰ : γ) => α) (fun (i : γ) => Preorder.toHasLe.{u1} α _inst_1)) (Function.comp.{succ u3, succ u2, succ u1} γ β α f g) (Function.comp.{succ u3, succ u2, succ u1} γ β α f h))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : β -> α} {g : γ -> β} {h : γ -> β}, (Monotone.{u2, u1} β α _inst_2 _inst_1 f) -> (LE.le.{max u2 u3} (γ -> β) (Pi.hasLe.{u3, u2} γ (fun (ᾰ : γ) => β) (fun (i : γ) => Preorder.toLE.{u2} β _inst_2)) g h) -> (LE.le.{max u3 u1} (γ -> α) (Pi.hasLe.{u3, u1} γ (fun (ᾰ : γ) => α) (fun (i : γ) => Preorder.toLE.{u1} α _inst_1)) (Function.comp.{succ u3, succ u2, succ u1} γ β α f g) (Function.comp.{succ u3, succ u2, succ u1} γ β α f h))
-Case conversion may be inaccurate. Consider using '#align monotone.comp_le_comp_left Monotone.comp_le_comp_leftₓ'. -/
 theorem Monotone.comp_le_comp_left [Preorder β] {f : β → α} {g h : γ → β} (hf : Monotone f)
     (le_gh : g ≤ h) : LE.le.{max w u} (f ∘ g) (f ∘ h) := fun x => hf (le_gh x)
 #align monotone.comp_le_comp_left Monotone.comp_le_comp_left
@@ -432,42 +426,18 @@ However if you find yourself writing `hf.imp h`, then you should have written `h
 -/
 
 
-/- warning: monotone.imp -> Monotone.imp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b))
-Case conversion may be inaccurate. Consider using '#align monotone.imp Monotone.impₓ'. -/
 theorem Monotone.imp (hf : Monotone f) (h : a ≤ b) : f a ≤ f b :=
   hf h
 #align monotone.imp Monotone.imp
 
-/- warning: antitone.imp -> Antitone.imp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f b) (f a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f b) (f a))
-Case conversion may be inaccurate. Consider using '#align antitone.imp Antitone.impₓ'. -/
 theorem Antitone.imp (hf : Antitone f) (h : a ≤ b) : f b ≤ f a :=
   hf h
 #align antitone.imp Antitone.imp
 
-/- warning: strict_mono.imp -> StrictMono.imp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b))
-Case conversion may be inaccurate. Consider using '#align strict_mono.imp StrictMono.impₓ'. -/
 theorem StrictMono.imp (hf : StrictMono f) (h : a < b) : f a < f b :=
   hf h
 #align strict_mono.imp StrictMono.imp
 
-/- warning: strict_anti.imp -> StrictAnti.imp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f b) (f a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f b) (f a))
-Case conversion may be inaccurate. Consider using '#align strict_anti.imp StrictAnti.impₓ'. -/
 theorem StrictAnti.imp (hf : StrictAnti f) (h : a < b) : f b < f a :=
   hf h
 #align strict_anti.imp StrictAnti.imp
@@ -550,46 +520,22 @@ section PartialOrder
 
 variable [PartialOrder α] [Preorder β] {f : α → β} {s : Set α}
 
-/- warning: monotone_iff_forall_lt -> monotone_iff_forall_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f) (forall {{a : α}} {{b : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f) (forall {{a : α}} {{b : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)))
-Case conversion may be inaccurate. Consider using '#align monotone_iff_forall_lt monotone_iff_forall_ltₓ'. -/
 theorem monotone_iff_forall_lt : Monotone f ↔ ∀ ⦃a b⦄, a < b → f a ≤ f b :=
   forall₂_congr fun a b =>
     ⟨fun hf h => hf h.le, fun hf h => h.eq_or_lt.elim (fun H => (congr_arg _ H).le) hf⟩
 #align monotone_iff_forall_lt monotone_iff_forall_lt
 
-/- warning: antitone_iff_forall_lt -> antitone_iff_forall_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f) (forall {{a : α}} {{b : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f b) (f a)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f) (forall {{a : α}} {{b : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f b) (f a)))
-Case conversion may be inaccurate. Consider using '#align antitone_iff_forall_lt antitone_iff_forall_ltₓ'. -/
 theorem antitone_iff_forall_lt : Antitone f ↔ ∀ ⦃a b⦄, a < b → f b ≤ f a :=
   forall₂_congr fun a b =>
     ⟨fun hf h => hf h.le, fun hf h => h.eq_or_lt.elim (fun H => (congr_arg _ H).ge) hf⟩
 #align antitone_iff_forall_lt antitone_iff_forall_lt
 
-/- warning: monotone_on_iff_forall_lt -> monotoneOn_iff_forall_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, Iff (MonotoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f s) (forall {{a : α}}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall {{b : α}}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, Iff (MonotoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f s) (forall {{a : α}}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall {{b : α}}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b))))
-Case conversion may be inaccurate. Consider using '#align monotone_on_iff_forall_lt monotoneOn_iff_forall_ltₓ'. -/
 theorem monotoneOn_iff_forall_lt :
     MonotoneOn f s ↔ ∀ ⦃a⦄ (ha : a ∈ s) ⦃b⦄ (hb : b ∈ s), a < b → f a ≤ f b :=
   ⟨fun hf a ha b hb h => hf ha hb h.le, fun hf a ha b hb h =>
     h.eq_or_lt.elim (fun H => (congr_arg _ H).le) (hf ha hb)⟩
 #align monotone_on_iff_forall_lt monotoneOn_iff_forall_lt
 
-/- warning: antitone_on_iff_forall_lt -> antitoneOn_iff_forall_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, Iff (AntitoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f s) (forall {{a : α}}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall {{b : α}}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f b) (f a))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, Iff (AntitoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f s) (forall {{a : α}}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall {{b : α}}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f b) (f a))))
-Case conversion may be inaccurate. Consider using '#align antitone_on_iff_forall_lt antitoneOn_iff_forall_ltₓ'. -/
 theorem antitoneOn_iff_forall_lt :
     AntitoneOn f s ↔ ∀ ⦃a⦄ (ha : a ∈ s) ⦃b⦄ (hb : b ∈ s), a < b → f b ≤ f a :=
   ⟨fun hf a ha b hb h => hf ha hb h.le, fun hf a ha b hb h =>
@@ -716,34 +662,16 @@ theorem antitoneOn_const [Preorder α] [Preorder β] {c : β} {s : Set α} :
 #align antitone_on_const antitoneOn_const
 -/
 
-/- warning: strict_mono_of_le_iff_le -> strictMono_of_le_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (forall (x : α) (y : α), Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) x y) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f x) (f y))) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (forall (x : α) (y : α), Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x y) (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f x) (f y))) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align strict_mono_of_le_iff_le strictMono_of_le_iff_leₓ'. -/
 theorem strictMono_of_le_iff_le [Preorder α] [Preorder β] {f : α → β}
     (h : ∀ x y, x ≤ y ↔ f x ≤ f y) : StrictMono f := fun a b =>
   (lt_iff_lt_of_le_iff_le' (h _ _) (h _ _)).1
 #align strict_mono_of_le_iff_le strictMono_of_le_iff_le
 
-/- warning: strict_anti_of_le_iff_le -> strictAnti_of_le_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (forall (x : α) (y : α), Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) x y) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f y) (f x))) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (forall (x : α) (y : α), Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x y) (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f y) (f x))) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align strict_anti_of_le_iff_le strictAnti_of_le_iff_leₓ'. -/
 theorem strictAnti_of_le_iff_le [Preorder α] [Preorder β] {f : α → β}
     (h : ∀ x y, x ≤ y ↔ f y ≤ f x) : StrictAnti f := fun a b =>
   (lt_iff_lt_of_le_iff_le' (h _ _) (h _ _)).1
 #align strict_anti_of_le_iff_le strictAnti_of_le_iff_le
 
-/- warning: injective_of_lt_imp_ne -> injective_of_lt_imp_ne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] {f : α -> β}, (forall (x : α) (y : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Ne.{succ u2} β (f x) (f y))) -> (Function.Injective.{succ u1, succ u2} α β f)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] {f : α -> β}, (forall (x : α) (y : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Ne.{succ u2} β (f x) (f y))) -> (Function.Injective.{succ u1, succ u2} α β f)
-Case conversion may be inaccurate. Consider using '#align injective_of_lt_imp_ne injective_of_lt_imp_neₓ'. -/
 theorem injective_of_lt_imp_ne [LinearOrder α] {f : α → β} (h : ∀ x y, x < y → f x ≠ f y) :
     Injective f := by
   intro x y hxy
@@ -752,12 +680,6 @@ theorem injective_of_lt_imp_ne [LinearOrder α] {f : α → β} (h : ∀ x y, x
   exacts[h _ _ hxy, (h _ _ hxy).symm]
 #align injective_of_lt_imp_ne injective_of_lt_imp_ne
 
-/- warning: injective_of_le_imp_le -> injective_of_le_imp_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β), (forall {x : α} {y : α}, (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f x) (f y)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x y)) -> (Function.Injective.{succ u1, succ u2} α β f)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β), (forall {x : α} {y : α}, (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f x) (f y)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x y)) -> (Function.Injective.{succ u1, succ u2} α β f)
-Case conversion may be inaccurate. Consider using '#align injective_of_le_imp_le injective_of_le_imp_leₓ'. -/
 theorem injective_of_le_imp_le [PartialOrder α] [Preorder β] (f : α → β)
     (h : ∀ {x y}, f x ≤ f y → x ≤ y) : Injective f := fun x y hxy => (h hxy.le).antisymm (h hxy.ge)
 #align injective_of_le_imp_le injective_of_le_imp_le
@@ -766,60 +688,30 @@ section Preorder
 
 variable [Preorder α] [Preorder β] {f g : α → β} {a : α}
 
-/- warning: strict_mono.is_max_of_apply -> StrictMono.isMax_of_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMax.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a)) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMax.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a)) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align strict_mono.is_max_of_apply StrictMono.isMax_of_applyₓ'. -/
 theorem StrictMono.isMax_of_apply (hf : StrictMono f) (ha : IsMax (f a)) : IsMax a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMax_iff.1 h
     (hf hb).not_isMax ha
 #align strict_mono.is_max_of_apply StrictMono.isMax_of_apply
 
-/- warning: strict_mono.is_min_of_apply -> StrictMono.isMin_of_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMin.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a)) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMin.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a)) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align strict_mono.is_min_of_apply StrictMono.isMin_of_applyₓ'. -/
 theorem StrictMono.isMin_of_apply (hf : StrictMono f) (ha : IsMin (f a)) : IsMin a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMin_iff.1 h
     (hf hb).not_isMin ha
 #align strict_mono.is_min_of_apply StrictMono.isMin_of_apply
 
-/- warning: strict_anti.is_max_of_apply -> StrictAnti.isMax_of_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMin.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a)) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMin.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a)) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align strict_anti.is_max_of_apply StrictAnti.isMax_of_applyₓ'. -/
 theorem StrictAnti.isMax_of_apply (hf : StrictAnti f) (ha : IsMin (f a)) : IsMax a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMax_iff.1 h
     (hf hb).not_isMin ha
 #align strict_anti.is_max_of_apply StrictAnti.isMax_of_apply
 
-/- warning: strict_anti.is_min_of_apply -> StrictAnti.isMin_of_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMax.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a)) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMax.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a)) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align strict_anti.is_min_of_apply StrictAnti.isMin_of_applyₓ'. -/
 theorem StrictAnti.isMin_of_apply (hf : StrictAnti f) (ha : IsMax (f a)) : IsMin a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMin_iff.1 h
     (hf hb).not_isMax ha
 #align strict_anti.is_min_of_apply StrictAnti.isMin_of_apply
 
-/- warning: strict_mono.ite' -> StrictMono.ite' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall {{x : α}} {{y : α}}, (p x) -> (Not (p y)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f x) (g y))) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall {{x : α}} {{y : α}}, (p x) -> (Not (p y)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f x) (g y))) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
-Case conversion may be inaccurate. Consider using '#align strict_mono.ite' StrictMono.ite'ₓ'. -/
 protected theorem StrictMono.ite' (hf : StrictMono f) (hg : StrictMono g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x)
     (hfg : ∀ ⦃x y⦄, p x → ¬p y → x < y → f x < g y) :
@@ -834,24 +726,12 @@ protected theorem StrictMono.ite' (hf : StrictMono f) (hg : StrictMono g) {p : 
   · simpa [hx, hy] using hg h
 #align strict_mono.ite' StrictMono.ite'
 
-/- warning: strict_mono.ite -> StrictMono.ite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f x) (g x)) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall (x : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f x) (g x)) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
-Case conversion may be inaccurate. Consider using '#align strict_mono.ite StrictMono.iteₓ'. -/
 protected theorem StrictMono.ite (hf : StrictMono f) (hg : StrictMono g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x) (hfg : ∀ x, f x ≤ g x) :
     StrictMono fun x => if p x then f x else g x :=
   hf.ite' hg hp fun x y hx hy h => (hf h).trans_le (hfg y)
 #align strict_mono.ite StrictMono.ite
 
-/- warning: strict_anti.ite' -> StrictAnti.ite' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall {{x : α}} {{y : α}}, (p x) -> (Not (p y)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (g y) (f x))) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall {{x : α}} {{y : α}}, (p x) -> (Not (p y)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (g y) (f x))) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
-Case conversion may be inaccurate. Consider using '#align strict_anti.ite' StrictAnti.ite'ₓ'. -/
 protected theorem StrictAnti.ite' (hf : StrictAnti f) (hg : StrictAnti g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x)
     (hfg : ∀ ⦃x y⦄, p x → ¬p y → x < y → g y < f x) :
@@ -859,12 +739,6 @@ protected theorem StrictAnti.ite' (hf : StrictAnti f) (hg : StrictAnti g) {p : 
   (StrictMono.ite' hf.dual_right hg.dual_right hp hfg).dual_right
 #align strict_anti.ite' StrictAnti.ite'
 
-/- warning: strict_anti.ite -> StrictAnti.ite is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (g x) (f x)) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall (x : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (g x) (f x)) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
-Case conversion may be inaccurate. Consider using '#align strict_anti.ite StrictAnti.iteₓ'. -/
 protected theorem StrictAnti.ite (hf : StrictAnti f) (hg : StrictAnti g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x) (hfg : ∀ x, g x ≤ f x) :
     StrictAnti fun x => if p x then f x else g x :=
@@ -1037,66 +911,30 @@ variable [Preorder β] {f : α → β} {s : Set α}
 
 open Ordering
 
-/- warning: monotone.reflect_lt -> Monotone.reflect_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
-Case conversion may be inaccurate. Consider using '#align monotone.reflect_lt Monotone.reflect_ltₓ'. -/
 theorem Monotone.reflect_lt (hf : Monotone f) {a b : α} (h : f a < f b) : a < b :=
   lt_of_not_ge fun h' => h.not_le (hf h')
 #align monotone.reflect_lt Monotone.reflect_lt
 
-/- warning: antitone.reflect_lt -> Antitone.reflect_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
-Case conversion may be inaccurate. Consider using '#align antitone.reflect_lt Antitone.reflect_ltₓ'. -/
 theorem Antitone.reflect_lt (hf : Antitone f) {a b : α} (h : f a < f b) : b < a :=
   lt_of_not_ge fun h' => h.not_le (hf h')
 #align antitone.reflect_lt Antitone.reflect_lt
 
-/- warning: monotone_on.reflect_lt -> MonotoneOn.reflect_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
-Case conversion may be inaccurate. Consider using '#align monotone_on.reflect_lt MonotoneOn.reflect_ltₓ'. -/
 theorem MonotoneOn.reflect_lt (hf : MonotoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
     (h : f a < f b) : a < b :=
   lt_of_not_ge fun h' => h.not_le <| hf hb ha h'
 #align monotone_on.reflect_lt MonotoneOn.reflect_lt
 
-/- warning: antitone_on.reflect_lt -> AntitoneOn.reflect_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
-Case conversion may be inaccurate. Consider using '#align antitone_on.reflect_lt AntitoneOn.reflect_ltₓ'. -/
 theorem AntitoneOn.reflect_lt (hf : AntitoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
     (h : f a < f b) : b < a :=
   lt_of_not_ge fun h' => h.not_le <| hf ha hb h'
 #align antitone_on.reflect_lt AntitoneOn.reflect_lt
 
-/- warning: strict_mono_on.le_iff_le -> StrictMonoOn.le_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Iff (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b)))
-Case conversion may be inaccurate. Consider using '#align strict_mono_on.le_iff_le StrictMonoOn.le_iff_leₓ'. -/
 theorem StrictMonoOn.le_iff_le (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a ≤ f b ↔ a ≤ b :=
   ⟨fun h => le_of_not_gt fun h' => (hf hb ha h').not_le h, fun h =>
     h.lt_or_eq_dec.elim (fun h' => (hf ha hb h').le) fun h' => h' ▸ le_rfl⟩
 #align strict_mono_on.le_iff_le StrictMonoOn.le_iff_le
 
-/- warning: strict_anti_on.le_iff_le -> StrictAntiOn.le_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Iff (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a)))
-Case conversion may be inaccurate. Consider using '#align strict_anti_on.le_iff_le StrictAntiOn.le_iff_leₓ'. -/
 theorem StrictAntiOn.le_iff_le (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a ≤ f b ↔ b ≤ a :=
   hf.dual_right.le_iff_le hb ha
@@ -1117,74 +955,32 @@ theorem StrictAntiOn.eq_iff_eq (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s)
 #align strict_anti_on.eq_iff_eq StrictAntiOn.eq_iff_eq
 -/
 
-/- warning: strict_mono_on.lt_iff_lt -> StrictMonoOn.lt_iff_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Iff (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Iff (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b)))
-Case conversion may be inaccurate. Consider using '#align strict_mono_on.lt_iff_lt StrictMonoOn.lt_iff_ltₓ'. -/
 theorem StrictMonoOn.lt_iff_lt (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a < f b ↔ a < b := by
   rw [lt_iff_le_not_le, lt_iff_le_not_le, hf.le_iff_le ha hb, hf.le_iff_le hb ha]
 #align strict_mono_on.lt_iff_lt StrictMonoOn.lt_iff_lt
 
-/- warning: strict_anti_on.lt_iff_lt -> StrictAntiOn.lt_iff_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Iff (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Iff (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a)))
-Case conversion may be inaccurate. Consider using '#align strict_anti_on.lt_iff_lt StrictAntiOn.lt_iff_ltₓ'. -/
 theorem StrictAntiOn.lt_iff_lt (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a < f b ↔ b < a :=
   hf.dual_right.lt_iff_lt hb ha
 #align strict_anti_on.lt_iff_lt StrictAntiOn.lt_iff_lt
 
-/- warning: strict_mono.le_iff_le -> StrictMono.le_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
-Case conversion may be inaccurate. Consider using '#align strict_mono.le_iff_le StrictMono.le_iff_leₓ'. -/
 theorem StrictMono.le_iff_le (hf : StrictMono f) {a b : α} : f a ≤ f b ↔ a ≤ b :=
   (hf.StrictMonoOn Set.univ).le_iff_le trivial trivial
 #align strict_mono.le_iff_le StrictMono.le_iff_le
 
-/- warning: strict_anti.le_iff_le -> StrictAnti.le_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
-Case conversion may be inaccurate. Consider using '#align strict_anti.le_iff_le StrictAnti.le_iff_leₓ'. -/
 theorem StrictAnti.le_iff_le (hf : StrictAnti f) {a b : α} : f a ≤ f b ↔ b ≤ a :=
   (hf.StrictAntiOn Set.univ).le_iff_le trivial trivial
 #align strict_anti.le_iff_le StrictAnti.le_iff_le
 
-/- warning: strict_mono.lt_iff_lt -> StrictMono.lt_iff_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
-Case conversion may be inaccurate. Consider using '#align strict_mono.lt_iff_lt StrictMono.lt_iff_ltₓ'. -/
 theorem StrictMono.lt_iff_lt (hf : StrictMono f) {a b : α} : f a < f b ↔ a < b :=
   (hf.StrictMonoOn Set.univ).lt_iff_lt trivial trivial
 #align strict_mono.lt_iff_lt StrictMono.lt_iff_lt
 
-/- warning: strict_anti.lt_iff_lt -> StrictAnti.lt_iff_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
-Case conversion may be inaccurate. Consider using '#align strict_anti.lt_iff_lt StrictAnti.lt_iff_ltₓ'. -/
 theorem StrictAnti.lt_iff_lt (hf : StrictAnti f) {a b : α} : f a < f b ↔ b < a :=
   (hf.StrictAntiOn Set.univ).lt_iff_lt trivial trivial
 #align strict_anti.lt_iff_lt StrictAnti.lt_iff_lt
 
-/- warning: strict_mono_on.compares -> StrictMonoOn.compares is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (forall {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (forall {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toLT.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b)))
-Case conversion may be inaccurate. Consider using '#align strict_mono_on.compares StrictMonoOn.comparesₓ'. -/
 protected theorem StrictMonoOn.compares (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s)
     (hb : b ∈ s) : ∀ {o : Ordering}, o.Compares (f a) (f b) ↔ o.Compares a b
   | Ordering.lt => hf.lt_iff_lt ha hb
@@ -1194,34 +990,16 @@ protected theorem StrictMonoOn.compares (hf : StrictMonoOn f s) {a b : α} (ha :
   | Ordering.gt => hf.lt_iff_lt hb ha
 #align strict_mono_on.compares StrictMonoOn.compares
 
-/- warning: strict_anti_on.compares -> StrictAntiOn.compares is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (forall {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o b a)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (forall {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toLT.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o b a)))
-Case conversion may be inaccurate. Consider using '#align strict_anti_on.compares StrictAntiOn.comparesₓ'. -/
 protected theorem StrictAntiOn.compares (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
     {o : Ordering} : o.Compares (f a) (f b) ↔ o.Compares b a :=
   toDual_compares_toDual.trans <| hf.dual_right.Compares hb ha
 #align strict_anti_on.compares StrictAntiOn.compares
 
-/- warning: strict_mono.compares -> StrictMono.compares is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α} {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α} {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toLT.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b))
-Case conversion may be inaccurate. Consider using '#align strict_mono.compares StrictMono.comparesₓ'. -/
 protected theorem StrictMono.compares (hf : StrictMono f) {a b : α} {o : Ordering} :
     o.Compares (f a) (f b) ↔ o.Compares a b :=
   (hf.StrictMonoOn Set.univ).Compares trivial trivial
 #align strict_mono.compares StrictMono.compares
 
-/- warning: strict_anti.compares -> StrictAnti.compares is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α} {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o b a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α} {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toLT.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o b a))
-Case conversion may be inaccurate. Consider using '#align strict_anti.compares StrictAnti.comparesₓ'. -/
 protected theorem StrictAnti.compares (hf : StrictAnti f) {a b : α} {o : Ordering} :
     o.Compares (f a) (f b) ↔ o.Compares b a :=
   (hf.StrictAntiOn Set.univ).Compares trivial trivial
@@ -1239,45 +1017,21 @@ theorem StrictAnti.injective (hf : StrictAnti f) : Injective f := fun x y h =>
 #align strict_anti.injective StrictAnti.injective
 -/
 
-/- warning: strict_mono.maximal_of_maximal_image -> StrictMono.maximal_of_maximal_image is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) p (f a)) -> (forall (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) p (f a)) -> (forall (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x a))
-Case conversion may be inaccurate. Consider using '#align strict_mono.maximal_of_maximal_image StrictMono.maximal_of_maximal_imageₓ'. -/
 theorem StrictMono.maximal_of_maximal_image (hf : StrictMono f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
     x ≤ a :=
   hf.le_iff_le.mp (hmax (f x))
 #align strict_mono.maximal_of_maximal_image StrictMono.maximal_of_maximal_image
 
-/- warning: strict_mono.minimal_of_minimal_image -> StrictMono.minimal_of_minimal_image is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) p) -> (forall (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) p) -> (forall (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a x))
-Case conversion may be inaccurate. Consider using '#align strict_mono.minimal_of_minimal_image StrictMono.minimal_of_minimal_imageₓ'. -/
 theorem StrictMono.minimal_of_minimal_image (hf : StrictMono f) {a} (hmin : ∀ p, f a ≤ p) (x : α) :
     a ≤ x :=
   hf.le_iff_le.mp (hmin (f x))
 #align strict_mono.minimal_of_minimal_image StrictMono.minimal_of_minimal_image
 
-/- warning: strict_anti.minimal_of_maximal_image -> StrictAnti.minimal_of_maximal_image is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) p (f a)) -> (forall (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a x))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) p (f a)) -> (forall (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a x))
-Case conversion may be inaccurate. Consider using '#align strict_anti.minimal_of_maximal_image StrictAnti.minimal_of_maximal_imageₓ'. -/
 theorem StrictAnti.minimal_of_maximal_image (hf : StrictAnti f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
     a ≤ x :=
   hf.le_iff_le.mp (hmax (f x))
 #align strict_anti.minimal_of_maximal_image StrictAnti.minimal_of_maximal_image
 
-/- warning: strict_anti.maximal_of_minimal_image -> StrictAnti.maximal_of_minimal_image is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) p) -> (forall (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x a))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) p) -> (forall (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x a))
-Case conversion may be inaccurate. Consider using '#align strict_anti.maximal_of_minimal_image StrictAnti.maximal_of_minimal_imageₓ'. -/
 theorem StrictAnti.maximal_of_minimal_image (hf : StrictAnti f) {a} (hmin : ∀ p, f a ≤ p) (x : α) :
     x ≤ a :=
   hf.le_iff_le.mp (hmin (f x))
@@ -1305,12 +1059,6 @@ end PartialOrder
 
 variable [LinearOrder β] {f : α → β} {s : Set α} {x y : α}
 
-/- warning: not_monotone_not_antitone_iff_exists_le_le -> not_monotone_not_antitone_iff_exists_le_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, Iff (And (Not (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f)) (Not (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f))) (Exists.{succ u1} α (fun (a : α) => Exists.{succ u1} α (fun (b : α) => Exists.{succ u1} α (fun (c : α) => And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b) (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b c) (Or (And (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f a) (f b)) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f c) (f b))) (And (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f a)) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f c)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, Iff (And (Not (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f)) (Not (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f))) (Exists.{succ u1} α (fun (a : α) => Exists.{succ u1} α (fun (b : α) => Exists.{succ u1} α (fun (c : α) => And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b) (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b c) (Or (And (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f a) (f b)) (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f c) (f b))) (And (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f a)) (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f c)))))))))
-Case conversion may be inaccurate. Consider using '#align not_monotone_not_antitone_iff_exists_le_le not_monotone_not_antitone_iff_exists_le_leₓ'. -/
 /-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
 downright. -/
 theorem not_monotone_not_antitone_iff_exists_le_le :
@@ -1343,12 +1091,6 @@ theorem not_monotone_not_antitone_iff_exists_le_le :
     · exact ⟨a, d, b, had, hdb, Or.inl ⟨hfac.trans_lt hfcd, hfbd⟩⟩
 #align not_monotone_not_antitone_iff_exists_le_le not_monotone_not_antitone_iff_exists_le_le
 
-/- warning: not_monotone_not_antitone_iff_exists_lt_lt -> not_monotone_not_antitone_iff_exists_lt_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, Iff (And (Not (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f)) (Not (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f))) (Exists.{succ u1} α (fun (a : α) => Exists.{succ u1} α (fun (b : α) => Exists.{succ u1} α (fun (c : α) => And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b) (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b c) (Or (And (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f a) (f b)) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f c) (f b))) (And (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f a)) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f c)))))))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, Iff (And (Not (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f)) (Not (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f))) (Exists.{succ u1} α (fun (a : α) => Exists.{succ u1} α (fun (b : α) => Exists.{succ u1} α (fun (c : α) => And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b) (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b c) (Or (And (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f a) (f b)) (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f c) (f b))) (And (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f a)) (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f c)))))))))
-Case conversion may be inaccurate. Consider using '#align not_monotone_not_antitone_iff_exists_lt_lt not_monotone_not_antitone_iff_exists_lt_ltₓ'. -/
 /-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
 downright. -/
 theorem not_monotone_not_antitone_iff_exists_lt_lt :
@@ -1434,54 +1176,24 @@ theorem Nat.rel_of_forall_rel_succ_of_le (r : β → β → Prop) [IsRefl β r]
 #align nat.rel_of_forall_rel_succ_of_le Nat.rel_of_forall_rel_succ_of_le
 -/
 
-/- warning: monotone_nat_of_le_succ -> monotone_nat_of_le_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))) -> (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))) -> (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align monotone_nat_of_le_succ monotone_nat_of_le_succₓ'. -/
 theorem monotone_nat_of_le_succ {f : ℕ → α} (hf : ∀ n, f n ≤ f (n + 1)) : Monotone f :=
   Nat.rel_of_forall_rel_succ_of_le (· ≤ ·) hf
 #align monotone_nat_of_le_succ monotone_nat_of_le_succ
 
-/- warning: antitone_nat_of_succ_le -> antitone_nat_of_succ_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f n)) -> (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f n)) -> (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align antitone_nat_of_succ_le antitone_nat_of_succ_leₓ'. -/
 theorem antitone_nat_of_succ_le {f : ℕ → α} (hf : ∀ n, f (n + 1) ≤ f n) : Antitone f :=
   @monotone_nat_of_le_succ αᵒᵈ _ _ hf
 #align antitone_nat_of_succ_le antitone_nat_of_succ_le
 
-/- warning: strict_mono_nat_of_lt_succ -> strictMono_nat_of_lt_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))) -> (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))) -> (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align strict_mono_nat_of_lt_succ strictMono_nat_of_lt_succₓ'. -/
 theorem strictMono_nat_of_lt_succ {f : ℕ → α} (hf : ∀ n, f n < f (n + 1)) : StrictMono f :=
   Nat.rel_of_forall_rel_succ_of_lt (· < ·) hf
 #align strict_mono_nat_of_lt_succ strictMono_nat_of_lt_succ
 
-/- warning: strict_anti_nat_of_succ_lt -> strictAnti_nat_of_succ_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f n)) -> (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f n)) -> (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align strict_anti_nat_of_succ_lt strictAnti_nat_of_succ_ltₓ'. -/
 theorem strictAnti_nat_of_succ_lt {f : ℕ → α} (hf : ∀ n, f (n + 1) < f n) : StrictAnti f :=
   @strictMono_nat_of_lt_succ αᵒᵈ _ f hf
 #align strict_anti_nat_of_succ_lt strictAnti_nat_of_succ_lt
 
 namespace Nat
 
-/- warning: nat.exists_strict_mono' -> Nat.exists_strictMono' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => And (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) (Eq.{succ u1} α (f (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => And (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) (Eq.{succ u1} α (f (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) a))
-Case conversion may be inaccurate. Consider using '#align nat.exists_strict_mono' Nat.exists_strictMono'ₓ'. -/
 /-- If `α` is a preorder with no maximal elements, then there exists a strictly monotone function
 `ℕ → α` with any prescribed value of `f 0`. -/
 theorem exists_strictMono' [NoMaxOrder α] (a : α) : ∃ f : ℕ → α, StrictMono f ∧ f 0 = a :=
@@ -1491,12 +1203,6 @@ theorem exists_strictMono' [NoMaxOrder α] (a : α) : ∃ f : ℕ → α, Strict
   exact ⟨fun n => Nat.recOn n a fun _ => g, strictMono_nat_of_lt_succ fun n => hg _, rfl⟩
 #align nat.exists_strict_mono' Nat.exists_strictMono'
 
-/- warning: nat.exists_strict_anti' -> Nat.exists_strictAnti' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => And (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) (Eq.{succ u1} α (f (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => And (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) (Eq.{succ u1} α (f (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) a))
-Case conversion may be inaccurate. Consider using '#align nat.exists_strict_anti' Nat.exists_strictAnti'ₓ'. -/
 /-- If `α` is a preorder with no maximal elements, then there exists a strictly antitone function
 `ℕ → α` with any prescribed value of `f 0`. -/
 theorem exists_strictAnti' [NoMinOrder α] (a : α) : ∃ f : ℕ → α, StrictAnti f ∧ f 0 = a :=
@@ -1505,12 +1211,6 @@ theorem exists_strictAnti' [NoMinOrder α] (a : α) : ∃ f : ℕ → α, Strict
 
 variable (α)
 
-/- warning: nat.exists_strict_mono -> Nat.exists_strictMono is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align nat.exists_strict_mono Nat.exists_strictMonoₓ'. -/
 /-- If `α` is a nonempty preorder with no maximal elements, then there exists a strictly monotone
 function `ℕ → α`. -/
 theorem exists_strictMono [Nonempty α] [NoMaxOrder α] : ∃ f : ℕ → α, StrictMono f :=
@@ -1519,12 +1219,6 @@ theorem exists_strictMono [Nonempty α] [NoMaxOrder α] : ∃ f : ℕ → α, St
   ⟨f, hf⟩
 #align nat.exists_strict_mono Nat.exists_strictMono
 
-/- warning: nat.exists_strict_anti -> Nat.exists_strictAnti is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align nat.exists_strict_anti Nat.exists_strictAntiₓ'. -/
 /-- If `α` is a nonempty preorder with no minimal elements, then there exists a strictly antitone
 function `ℕ → α`. -/
 theorem exists_strictAnti [Nonempty α] [NoMinOrder α] : ∃ f : ℕ → α, StrictAnti f :=
@@ -1552,42 +1246,18 @@ theorem Int.rel_of_forall_rel_succ_of_le (r : β → β → Prop) [IsRefl β r]
 #align int.rel_of_forall_rel_succ_of_le Int.rel_of_forall_rel_succ_of_le
 -/
 
-/- warning: monotone_int_of_le_succ -> monotone_int_of_le_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))))) -> (Monotone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))))) -> (Monotone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align monotone_int_of_le_succ monotone_int_of_le_succₓ'. -/
 theorem monotone_int_of_le_succ {f : ℤ → α} (hf : ∀ n, f n ≤ f (n + 1)) : Monotone f :=
   Int.rel_of_forall_rel_succ_of_le (· ≤ ·) hf
 #align monotone_int_of_le_succ monotone_int_of_le_succ
 
-/- warning: antitone_int_of_succ_le -> antitone_int_of_succ_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) (f n)) -> (Antitone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) (f n)) -> (Antitone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align antitone_int_of_succ_le antitone_int_of_succ_leₓ'. -/
 theorem antitone_int_of_succ_le {f : ℤ → α} (hf : ∀ n, f (n + 1) ≤ f n) : Antitone f :=
   Int.rel_of_forall_rel_succ_of_le (· ≥ ·) hf
 #align antitone_int_of_succ_le antitone_int_of_succ_le
 
-/- warning: strict_mono_int_of_lt_succ -> strictMono_int_of_lt_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))))) -> (StrictMono.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))))) -> (StrictMono.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align strict_mono_int_of_lt_succ strictMono_int_of_lt_succₓ'. -/
 theorem strictMono_int_of_lt_succ {f : ℤ → α} (hf : ∀ n, f n < f (n + 1)) : StrictMono f :=
   Int.rel_of_forall_rel_succ_of_lt (· < ·) hf
 #align strict_mono_int_of_lt_succ strictMono_int_of_lt_succ
 
-/- warning: strict_anti_int_of_succ_lt -> strictAnti_int_of_succ_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) (f n)) -> (StrictAnti.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) (f n)) -> (StrictAnti.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align strict_anti_int_of_succ_lt strictAnti_int_of_succ_ltₓ'. -/
 theorem strictAnti_int_of_succ_lt {f : ℤ → α} (hf : ∀ n, f (n + 1) < f n) : StrictAnti f :=
   Int.rel_of_forall_rel_succ_of_lt (· > ·) hf
 #align strict_anti_int_of_succ_lt strictAnti_int_of_succ_lt
@@ -1596,12 +1266,6 @@ namespace Int
 
 variable (α) [Nonempty α] [NoMinOrder α] [NoMaxOrder α]
 
-/- warning: int.exists_strict_mono -> Int.exists_strictMono is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Exists.{succ u1} (Int -> α) (fun (f : Int -> α) => StrictMono.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Exists.{succ u1} (Int -> α) (fun (f : Int -> α) => StrictMono.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align int.exists_strict_mono Int.exists_strictMonoₓ'. -/
 /-- If `α` is a nonempty preorder with no minimal or maximal elements, then there exists a strictly
 monotone function `f : ℤ → α`. -/
 theorem exists_strictMono : ∃ f : ℤ → α, StrictMono f :=
@@ -1618,12 +1282,6 @@ theorem exists_strictMono : ∃ f : ℤ → α, StrictMono f :=
   · exact hg (Nat.lt_succ_self _)
 #align int.exists_strict_mono Int.exists_strictMono
 
-/- warning: int.exists_strict_anti -> Int.exists_strictAnti is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Exists.{succ u1} (Int -> α) (fun (f : Int -> α) => StrictAnti.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Exists.{succ u1} (Int -> α) (fun (f : Int -> α) => StrictAnti.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
-Case conversion may be inaccurate. Consider using '#align int.exists_strict_anti Int.exists_strictAntiₓ'. -/
 /-- If `α` is a nonempty preorder with no minimal or maximal elements, then there exists a strictly
 antitone function `f : ℤ → α`. -/
 theorem exists_strictAnti : ∃ f : ℤ → α, StrictAnti f :=
@@ -1632,12 +1290,6 @@ theorem exists_strictAnti : ∃ f : ℤ → α, StrictAnti f :=
 
 end Int
 
-/- warning: monotone.ne_of_lt_of_lt_nat -> Monotone.ne_of_lt_of_lt_nat is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) -> (forall (n : Nat) {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f n) x) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))) -> (forall (a : Nat), Ne.{succ u1} α (f a) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) -> (forall (n : Nat) {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f n) x) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))) -> (forall (a : Nat), Ne.{succ u1} α (f a) x))
-Case conversion may be inaccurate. Consider using '#align monotone.ne_of_lt_of_lt_nat Monotone.ne_of_lt_of_lt_natₓ'. -/
 -- TODO@Yael: Generalize the following four to succ orders
 /-- If `f` is a monotone function from `ℕ` to a preorder such that `x` lies between `f n` and
   `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/
@@ -1646,12 +1298,6 @@ theorem Monotone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Monotone f) (n : ℕ)
   exact (hf.reflect_lt h1).not_le (Nat.le_of_lt_succ <| hf.reflect_lt h2)
 #align monotone.ne_of_lt_of_lt_nat Monotone.ne_of_lt_of_lt_nat
 
-/- warning: antitone.ne_of_lt_of_lt_nat -> Antitone.ne_of_lt_of_lt_nat is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) -> (forall (n : Nat) {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) x) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x (f n)) -> (forall (a : Nat), Ne.{succ u1} α (f a) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) -> (forall (n : Nat) {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) x) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f n)) -> (forall (a : Nat), Ne.{succ u1} α (f a) x))
-Case conversion may be inaccurate. Consider using '#align antitone.ne_of_lt_of_lt_nat Antitone.ne_of_lt_of_lt_natₓ'. -/
 /-- If `f` is an antitone function from `ℕ` to a preorder such that `x` lies between `f (n + 1)` and
 `f n`, then `x` doesn't lie in the range of `f`. -/
 theorem Antitone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Antitone f) (n : ℕ) {x : α}
@@ -1659,12 +1305,6 @@ theorem Antitone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Antitone f) (n : ℕ)
   exact (hf.reflect_lt h2).not_le (Nat.le_of_lt_succ <| hf.reflect_lt h1)
 #align antitone.ne_of_lt_of_lt_nat Antitone.ne_of_lt_of_lt_nat
 
-/- warning: monotone.ne_of_lt_of_lt_int -> Monotone.ne_of_lt_of_lt_int is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (Monotone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f) -> (forall (n : Int) {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f n) x) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))))) -> (forall (a : Int), Ne.{succ u1} α (f a) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (Monotone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f) -> (forall (n : Int) {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f n) x) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))))) -> (forall (a : Int), Ne.{succ u1} α (f a) x))
-Case conversion may be inaccurate. Consider using '#align monotone.ne_of_lt_of_lt_int Monotone.ne_of_lt_of_lt_intₓ'. -/
 /-- If `f` is a monotone function from `ℤ` to a preorder and `x` lies between `f n` and
   `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/
 theorem Monotone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Monotone f) (n : ℤ) {x : α} (h1 : f n < x)
@@ -1672,12 +1312,6 @@ theorem Monotone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Monotone f) (n : ℤ)
   exact (hf.reflect_lt h1).not_le (Int.le_of_lt_add_one <| hf.reflect_lt h2)
 #align monotone.ne_of_lt_of_lt_int Monotone.ne_of_lt_of_lt_int
 
-/- warning: antitone.ne_of_lt_of_lt_int -> Antitone.ne_of_lt_of_lt_int is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (Antitone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f) -> (forall (n : Int) {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) x) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x (f n)) -> (forall (a : Int), Ne.{succ u1} α (f a) x))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (Antitone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f) -> (forall (n : Int) {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) x) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f n)) -> (forall (a : Int), Ne.{succ u1} α (f a) x))
-Case conversion may be inaccurate. Consider using '#align antitone.ne_of_lt_of_lt_int Antitone.ne_of_lt_of_lt_intₓ'. -/
 /-- If `f` is an antitone function from `ℤ` to a preorder and `x` lies between `f (n + 1)` and
 `f n`, then `x` doesn't lie in the range of `f`. -/
 theorem Antitone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Antitone f) (n : ℤ) {x : α}
@@ -1708,40 +1342,16 @@ section Preorder
 
 variable [Preorder α] [Preorder β] [Preorder γ] [Preorder δ] {f : α → γ} {g : β → δ} {a b : α}
 
-/- warning: monotone_fst -> monotone_fst is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β], Monotone.{max u1 u2, u1} (Prod.{u1, u2} α β) α (Prod.preorder.{u1, u2} α β _inst_1 _inst_2) _inst_1 (Prod.fst.{u1, u2} α β)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β], Monotone.{max u1 u2, u1} (Prod.{u1, u2} α β) α (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2) _inst_1 (Prod.fst.{u1, u2} α β)
-Case conversion may be inaccurate. Consider using '#align monotone_fst monotone_fstₓ'. -/
 theorem monotone_fst : Monotone (@Prod.fst α β) := fun a b => And.left
 #align monotone_fst monotone_fst
 
-/- warning: monotone_snd -> monotone_snd is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β], Monotone.{max u1 u2, u2} (Prod.{u1, u2} α β) β (Prod.preorder.{u1, u2} α β _inst_1 _inst_2) _inst_2 (Prod.snd.{u1, u2} α β)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β], Monotone.{max u1 u2, u2} (Prod.{u1, u2} α β) β (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2) _inst_2 (Prod.snd.{u1, u2} α β)
-Case conversion may be inaccurate. Consider using '#align monotone_snd monotone_sndₓ'. -/
 theorem monotone_snd : Monotone (@Prod.snd α β) := fun a b => And.right
 #align monotone_snd monotone_snd
 
-/- warning: monotone.prod_map -> Monotone.prod_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : Preorder.{u3} γ] [_inst_4 : Preorder.{u4} δ] {f : α -> γ} {g : β -> δ}, (Monotone.{u1, u3} α γ _inst_1 _inst_3 f) -> (Monotone.{u2, u4} β δ _inst_2 _inst_4 g) -> (Monotone.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ) (Prod.preorder.{u1, u2} α β _inst_1 _inst_2) (Prod.preorder.{u3, u4} γ δ _inst_3 _inst_4) (Prod.map.{u1, u3, u2, u4} α γ β δ f g))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {γ : Type.{u4}} {δ : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u3} β] [_inst_3 : Preorder.{u4} γ] [_inst_4 : Preorder.{u1} δ] {f : α -> γ} {g : β -> δ}, (Monotone.{u2, u4} α γ _inst_1 _inst_3 f) -> (Monotone.{u3, u1} β δ _inst_2 _inst_4 g) -> (Monotone.{max u3 u2, max u1 u4} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ) (Prod.instPreorderProd.{u2, u3} α β _inst_1 _inst_2) (Prod.instPreorderProd.{u4, u1} γ δ _inst_3 _inst_4) (Prod.map.{u2, u4, u3, u1} α γ β δ f g))
-Case conversion may be inaccurate. Consider using '#align monotone.prod_map Monotone.prod_mapₓ'. -/
 theorem Monotone.prod_map (hf : Monotone f) (hg : Monotone g) : Monotone (Prod.map f g) :=
   fun a b h => ⟨hf h.1, hg h.2⟩
 #align monotone.prod_map Monotone.prod_map
 
-/- warning: antitone.prod_map -> Antitone.prod_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : Preorder.{u3} γ] [_inst_4 : Preorder.{u4} δ] {f : α -> γ} {g : β -> δ}, (Antitone.{u1, u3} α γ _inst_1 _inst_3 f) -> (Antitone.{u2, u4} β δ _inst_2 _inst_4 g) -> (Antitone.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ) (Prod.preorder.{u1, u2} α β _inst_1 _inst_2) (Prod.preorder.{u3, u4} γ δ _inst_3 _inst_4) (Prod.map.{u1, u3, u2, u4} α γ β δ f g))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {γ : Type.{u4}} {δ : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u3} β] [_inst_3 : Preorder.{u4} γ] [_inst_4 : Preorder.{u1} δ] {f : α -> γ} {g : β -> δ}, (Antitone.{u2, u4} α γ _inst_1 _inst_3 f) -> (Antitone.{u3, u1} β δ _inst_2 _inst_4 g) -> (Antitone.{max u3 u2, max u1 u4} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ) (Prod.instPreorderProd.{u2, u3} α β _inst_1 _inst_2) (Prod.instPreorderProd.{u4, u1} γ δ _inst_3 _inst_4) (Prod.map.{u2, u4, u3, u1} α γ β δ f g))
-Case conversion may be inaccurate. Consider using '#align antitone.prod_map Antitone.prod_mapₓ'. -/
 theorem Antitone.prod_map (hf : Antitone f) (hg : Antitone g) : Antitone (Prod.map f g) :=
   fun a b h => ⟨hf h.1, hg h.2⟩
 #align antitone.prod_map Antitone.prod_map
@@ -1752,24 +1362,12 @@ section PartialOrder
 
 variable [PartialOrder α] [PartialOrder β] [Preorder γ] [Preorder δ] {f : α → γ} {g : β → δ}
 
-/- warning: strict_mono.prod_map -> StrictMono.prod_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : Preorder.{u3} γ] [_inst_4 : Preorder.{u4} δ] {f : α -> γ} {g : β -> δ}, (StrictMono.{u1, u3} α γ (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 f) -> (StrictMono.{u2, u4} β δ (PartialOrder.toPreorder.{u2} β _inst_2) _inst_4 g) -> (StrictMono.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ) (Prod.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)) (Prod.preorder.{u3, u4} γ δ _inst_3 _inst_4) (Prod.map.{u1, u3, u2, u4} α γ β δ f g))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {γ : Type.{u4}} {δ : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PartialOrder.{u3} β] [_inst_3 : Preorder.{u4} γ] [_inst_4 : Preorder.{u1} δ] {f : α -> γ} {g : β -> δ}, (StrictMono.{u2, u4} α γ (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 f) -> (StrictMono.{u3, u1} β δ (PartialOrder.toPreorder.{u3} β _inst_2) _inst_4 g) -> (StrictMono.{max u3 u2, max u1 u4} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ) (Prod.instPreorderProd.{u2, u3} α β (PartialOrder.toPreorder.{u2} α _inst_1) (PartialOrder.toPreorder.{u3} β _inst_2)) (Prod.instPreorderProd.{u4, u1} γ δ _inst_3 _inst_4) (Prod.map.{u2, u4, u3, u1} α γ β δ f g))
-Case conversion may be inaccurate. Consider using '#align strict_mono.prod_map StrictMono.prod_mapₓ'. -/
 theorem StrictMono.prod_map (hf : StrictMono f) (hg : StrictMono g) : StrictMono (Prod.map f g) :=
   fun a b => by
   simp_rw [Prod.lt_iff]
   exact Or.imp (And.imp hf.imp hg.monotone.imp) (And.imp hf.monotone.imp hg.imp)
 #align strict_mono.prod_map StrictMono.prod_map
 
-/- warning: strict_anti.prod_map -> StrictAnti.prod_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PartialOrder.{u2} β] [_inst_3 : Preorder.{u3} γ] [_inst_4 : Preorder.{u4} δ] {f : α -> γ} {g : β -> δ}, (StrictAnti.{u1, u3} α γ (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 f) -> (StrictAnti.{u2, u4} β δ (PartialOrder.toPreorder.{u2} β _inst_2) _inst_4 g) -> (StrictAnti.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ) (Prod.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u2} β _inst_2)) (Prod.preorder.{u3, u4} γ δ _inst_3 _inst_4) (Prod.map.{u1, u3, u2, u4} α γ β δ f g))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u3}} {γ : Type.{u4}} {δ : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PartialOrder.{u3} β] [_inst_3 : Preorder.{u4} γ] [_inst_4 : Preorder.{u1} δ] {f : α -> γ} {g : β -> δ}, (StrictAnti.{u2, u4} α γ (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 f) -> (StrictAnti.{u3, u1} β δ (PartialOrder.toPreorder.{u3} β _inst_2) _inst_4 g) -> (StrictAnti.{max u3 u2, max u1 u4} (Prod.{u2, u3} α β) (Prod.{u4, u1} γ δ) (Prod.instPreorderProd.{u2, u3} α β (PartialOrder.toPreorder.{u2} α _inst_1) (PartialOrder.toPreorder.{u3} β _inst_2)) (Prod.instPreorderProd.{u4, u1} γ δ _inst_3 _inst_4) (Prod.map.{u2, u4, u3, u1} α γ β δ f g))
-Case conversion may be inaccurate. Consider using '#align strict_anti.prod_map StrictAnti.prod_mapₓ'. -/
 theorem StrictAnti.prod_map (hf : StrictAnti f) (hg : StrictAnti g) : StrictAnti (Prod.map f g) :=
   fun a b => by
   simp_rw [Prod.lt_iff]

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

@@ -1105,10 +1105,8 @@ theorem StrictAntiOn.le_iff_le (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s)
 #print StrictMonoOn.eq_iff_eq /-
 theorem StrictMonoOn.eq_iff_eq (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a = f b ↔ a = b :=
-  ⟨fun h => le_antisymm ((hf.le_iff_le ha hb).mp h.le) ((hf.le_iff_le hb ha).mp h.ge),
-    by
-    rintro rfl
-    rfl⟩
+  ⟨fun h => le_antisymm ((hf.le_iff_le ha hb).mp h.le) ((hf.le_iff_le hb ha).mp h.ge), by
+    rintro rfl; rfl⟩
 #align strict_mono_on.eq_iff_eq StrictMonoOn.eq_iff_eq
 -/
 
@@ -1541,8 +1539,7 @@ theorem Int.rel_of_forall_rel_succ_of_lt (r : β → β → Prop) [IsTrans β r]
   by
   rcases hab.dest with ⟨n, rfl⟩; clear hab
   induction' n with n ihn
-  · rw [Int.ofNat_one]
-    apply h
+  · rw [Int.ofNat_one]; apply h
   · rw [Int.ofNat_succ, ← Int.add_assoc]
     exact trans ihn (h _)
 #align int.rel_of_forall_rel_succ_of_lt Int.rel_of_forall_rel_succ_of_lt
@@ -1645,9 +1642,7 @@ Case conversion may be inaccurate. Consider using '#align monotone.ne_of_lt_of_l
 /-- If `f` is a monotone function from `ℕ` to a preorder such that `x` lies between `f n` and
   `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/
 theorem Monotone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Monotone f) (n : ℕ) {x : α} (h1 : f n < x)
-    (h2 : x < f (n + 1)) (a : ℕ) : f a ≠ x :=
-  by
-  rintro rfl
+    (h2 : x < f (n + 1)) (a : ℕ) : f a ≠ x := by rintro rfl;
   exact (hf.reflect_lt h1).not_le (Nat.le_of_lt_succ <| hf.reflect_lt h2)
 #align monotone.ne_of_lt_of_lt_nat Monotone.ne_of_lt_of_lt_nat
 
@@ -1660,9 +1655,7 @@ Case conversion may be inaccurate. Consider using '#align antitone.ne_of_lt_of_l
 /-- If `f` is an antitone function from `ℕ` to a preorder such that `x` lies between `f (n + 1)` and
 `f n`, then `x` doesn't lie in the range of `f`. -/
 theorem Antitone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Antitone f) (n : ℕ) {x : α}
-    (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℕ) : f a ≠ x :=
-  by
-  rintro rfl
+    (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℕ) : f a ≠ x := by rintro rfl;
   exact (hf.reflect_lt h2).not_le (Nat.le_of_lt_succ <| hf.reflect_lt h1)
 #align antitone.ne_of_lt_of_lt_nat Antitone.ne_of_lt_of_lt_nat
 
@@ -1675,9 +1668,7 @@ Case conversion may be inaccurate. Consider using '#align monotone.ne_of_lt_of_l
 /-- If `f` is a monotone function from `ℤ` to a preorder and `x` lies between `f n` and
   `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/
 theorem Monotone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Monotone f) (n : ℤ) {x : α} (h1 : f n < x)
-    (h2 : x < f (n + 1)) (a : ℤ) : f a ≠ x :=
-  by
-  rintro rfl
+    (h2 : x < f (n + 1)) (a : ℤ) : f a ≠ x := by rintro rfl;
   exact (hf.reflect_lt h1).not_le (Int.le_of_lt_add_one <| hf.reflect_lt h2)
 #align monotone.ne_of_lt_of_lt_int Monotone.ne_of_lt_of_lt_int
 
@@ -1690,9 +1681,7 @@ Case conversion may be inaccurate. Consider using '#align antitone.ne_of_lt_of_l
 /-- If `f` is an antitone function from `ℤ` to a preorder and `x` lies between `f (n + 1)` and
 `f n`, then `x` doesn't lie in the range of `f`. -/
 theorem Antitone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Antitone f) (n : ℤ) {x : α}
-    (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℤ) : f a ≠ x :=
-  by
-  rintro rfl
+    (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℤ) : f a ≠ x := by rintro rfl;
   exact (hf.reflect_lt h2).not_le (Int.le_of_lt_add_one <| hf.reflect_lt h1)
 #align antitone.ne_of_lt_of_lt_int Antitone.ne_of_lt_of_lt_int
 

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

@@ -370,11 +370,15 @@ section Preorder
 
 variable [Preorder α]
 
-#print Monotone.comp_le_comp_left /-
+/- warning: monotone.comp_le_comp_left -> Monotone.comp_le_comp_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : β -> α} {g : γ -> β} {h : γ -> β}, (Monotone.{u2, u1} β α _inst_2 _inst_1 f) -> (LE.le.{max u3 u2} (γ -> β) (Pi.hasLe.{u3, u2} γ (fun (ᾰ : γ) => β) (fun (i : γ) => Preorder.toHasLe.{u2} β _inst_2)) g h) -> (LE.le.{max u3 u1} (γ -> α) (Pi.hasLe.{u3, u1} γ (fun (ᾰ : γ) => α) (fun (i : γ) => Preorder.toHasLe.{u1} α _inst_1)) (Function.comp.{succ u3, succ u2, succ u1} γ β α f g) (Function.comp.{succ u3, succ u2, succ u1} γ β α f h))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : β -> α} {g : γ -> β} {h : γ -> β}, (Monotone.{u2, u1} β α _inst_2 _inst_1 f) -> (LE.le.{max u2 u3} (γ -> β) (Pi.hasLe.{u3, u2} γ (fun (ᾰ : γ) => β) (fun (i : γ) => Preorder.toLE.{u2} β _inst_2)) g h) -> (LE.le.{max u3 u1} (γ -> α) (Pi.hasLe.{u3, u1} γ (fun (ᾰ : γ) => α) (fun (i : γ) => Preorder.toLE.{u1} α _inst_1)) (Function.comp.{succ u3, succ u2, succ u1} γ β α f g) (Function.comp.{succ u3, succ u2, succ u1} γ β α f h))
+Case conversion may be inaccurate. Consider using '#align monotone.comp_le_comp_left Monotone.comp_le_comp_leftₓ'. -/
 theorem Monotone.comp_le_comp_left [Preorder β] {f : β → α} {g h : γ → β} (hf : Monotone f)
     (le_gh : g ≤ h) : LE.le.{max w u} (f ∘ g) (f ∘ h) := fun x => hf (le_gh x)
 #align monotone.comp_le_comp_left Monotone.comp_le_comp_left
--/
 
 variable [Preorder γ]
 
@@ -428,29 +432,45 @@ However if you find yourself writing `hf.imp h`, then you should have written `h
 -/
 
 
-#print Monotone.imp /-
+/- warning: monotone.imp -> Monotone.imp is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b))
+Case conversion may be inaccurate. Consider using '#align monotone.imp Monotone.impₓ'. -/
 theorem Monotone.imp (hf : Monotone f) (h : a ≤ b) : f a ≤ f b :=
   hf h
 #align monotone.imp Monotone.imp
--/
 
-#print Antitone.imp /-
+/- warning: antitone.imp -> Antitone.imp is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f b) (f a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f b) (f a))
+Case conversion may be inaccurate. Consider using '#align antitone.imp Antitone.impₓ'. -/
 theorem Antitone.imp (hf : Antitone f) (h : a ≤ b) : f b ≤ f a :=
   hf h
 #align antitone.imp Antitone.imp
--/
 
-#print StrictMono.imp /-
+/- warning: strict_mono.imp -> StrictMono.imp is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b))
+Case conversion may be inaccurate. Consider using '#align strict_mono.imp StrictMono.impₓ'. -/
 theorem StrictMono.imp (hf : StrictMono f) (h : a < b) : f a < f b :=
   hf h
 #align strict_mono.imp StrictMono.imp
--/
 
-#print StrictAnti.imp /-
+/- warning: strict_anti.imp -> StrictAnti.imp is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f b) (f a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α} {b : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f b) (f a))
+Case conversion may be inaccurate. Consider using '#align strict_anti.imp StrictAnti.impₓ'. -/
 theorem StrictAnti.imp (hf : StrictAnti f) (h : a < b) : f b < f a :=
   hf h
 #align strict_anti.imp StrictAnti.imp
--/
 
 #print Monotone.monotoneOn /-
 protected theorem Monotone.monotoneOn (hf : Monotone f) (s : Set α) : MonotoneOn f s :=
@@ -530,35 +550,51 @@ section PartialOrder
 
 variable [PartialOrder α] [Preorder β] {f : α → β} {s : Set α}
 
-#print monotone_iff_forall_lt /-
+/- warning: monotone_iff_forall_lt -> monotone_iff_forall_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f) (forall {{a : α}} {{b : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f) (forall {{a : α}} {{b : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)))
+Case conversion may be inaccurate. Consider using '#align monotone_iff_forall_lt monotone_iff_forall_ltₓ'. -/
 theorem monotone_iff_forall_lt : Monotone f ↔ ∀ ⦃a b⦄, a < b → f a ≤ f b :=
   forall₂_congr fun a b =>
     ⟨fun hf h => hf h.le, fun hf h => h.eq_or_lt.elim (fun H => (congr_arg _ H).le) hf⟩
 #align monotone_iff_forall_lt monotone_iff_forall_lt
--/
 
-#print antitone_iff_forall_lt /-
+/- warning: antitone_iff_forall_lt -> antitone_iff_forall_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f) (forall {{a : α}} {{b : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f b) (f a)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, Iff (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f) (forall {{a : α}} {{b : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f b) (f a)))
+Case conversion may be inaccurate. Consider using '#align antitone_iff_forall_lt antitone_iff_forall_ltₓ'. -/
 theorem antitone_iff_forall_lt : Antitone f ↔ ∀ ⦃a b⦄, a < b → f b ≤ f a :=
   forall₂_congr fun a b =>
     ⟨fun hf h => hf h.le, fun hf h => h.eq_or_lt.elim (fun H => (congr_arg _ H).ge) hf⟩
 #align antitone_iff_forall_lt antitone_iff_forall_lt
--/
 
-#print monotoneOn_iff_forall_lt /-
+/- warning: monotone_on_iff_forall_lt -> monotoneOn_iff_forall_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, Iff (MonotoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f s) (forall {{a : α}}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall {{b : α}}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, Iff (MonotoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f s) (forall {{a : α}}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall {{b : α}}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b))))
+Case conversion may be inaccurate. Consider using '#align monotone_on_iff_forall_lt monotoneOn_iff_forall_ltₓ'. -/
 theorem monotoneOn_iff_forall_lt :
     MonotoneOn f s ↔ ∀ ⦃a⦄ (ha : a ∈ s) ⦃b⦄ (hb : b ∈ s), a < b → f a ≤ f b :=
   ⟨fun hf a ha b hb h => hf ha hb h.le, fun hf a ha b hb h =>
     h.eq_or_lt.elim (fun H => (congr_arg _ H).le) (hf ha hb)⟩
 #align monotone_on_iff_forall_lt monotoneOn_iff_forall_lt
--/
 
-#print antitoneOn_iff_forall_lt /-
+/- warning: antitone_on_iff_forall_lt -> antitoneOn_iff_forall_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, Iff (AntitoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f s) (forall {{a : α}}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall {{b : α}}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f b) (f a))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, Iff (AntitoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 f s) (forall {{a : α}}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (forall {{b : α}}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f b) (f a))))
+Case conversion may be inaccurate. Consider using '#align antitone_on_iff_forall_lt antitoneOn_iff_forall_ltₓ'. -/
 theorem antitoneOn_iff_forall_lt :
     AntitoneOn f s ↔ ∀ ⦃a⦄ (ha : a ∈ s) ⦃b⦄ (hb : b ∈ s), a < b → f b ≤ f a :=
   ⟨fun hf a ha b hb h => hf ha hb h.le, fun hf a ha b hb h =>
     h.eq_or_lt.elim (fun H => (congr_arg _ H).ge) (hf ha hb)⟩
 #align antitone_on_iff_forall_lt antitoneOn_iff_forall_lt
--/
 
 #print StrictMonoOn.monotoneOn /-
 -- `preorder α` isn't strong enough: if the preorder on `α` is an equivalence relation,
@@ -680,21 +716,34 @@ theorem antitoneOn_const [Preorder α] [Preorder β] {c : β} {s : Set α} :
 #align antitone_on_const antitoneOn_const
 -/
 
-#print strictMono_of_le_iff_le /-
+/- warning: strict_mono_of_le_iff_le -> strictMono_of_le_iff_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (forall (x : α) (y : α), Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) x y) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f x) (f y))) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 f)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (forall (x : α) (y : α), Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x y) (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f x) (f y))) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align strict_mono_of_le_iff_le strictMono_of_le_iff_leₓ'. -/
 theorem strictMono_of_le_iff_le [Preorder α] [Preorder β] {f : α → β}
     (h : ∀ x y, x ≤ y ↔ f x ≤ f y) : StrictMono f := fun a b =>
   (lt_iff_lt_of_le_iff_le' (h _ _) (h _ _)).1
 #align strict_mono_of_le_iff_le strictMono_of_le_iff_le
--/
 
-#print strictAnti_of_le_iff_le /-
+/- warning: strict_anti_of_le_iff_le -> strictAnti_of_le_iff_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (forall (x : α) (y : α), Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) x y) (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f y) (f x))) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (forall (x : α) (y : α), Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x y) (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f y) (f x))) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align strict_anti_of_le_iff_le strictAnti_of_le_iff_leₓ'. -/
 theorem strictAnti_of_le_iff_le [Preorder α] [Preorder β] {f : α → β}
     (h : ∀ x y, x ≤ y ↔ f y ≤ f x) : StrictAnti f := fun a b =>
   (lt_iff_lt_of_le_iff_le' (h _ _) (h _ _)).1
 #align strict_anti_of_le_iff_le strictAnti_of_le_iff_le
--/
 
-#print injective_of_lt_imp_ne /-
+/- warning: injective_of_lt_imp_ne -> injective_of_lt_imp_ne is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] {f : α -> β}, (forall (x : α) (y : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Ne.{succ u2} β (f x) (f y))) -> (Function.Injective.{succ u1, succ u2} α β f)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] {f : α -> β}, (forall (x : α) (y : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Ne.{succ u2} β (f x) (f y))) -> (Function.Injective.{succ u1, succ u2} α β f)
+Case conversion may be inaccurate. Consider using '#align injective_of_lt_imp_ne injective_of_lt_imp_neₓ'. -/
 theorem injective_of_lt_imp_ne [LinearOrder α] {f : α → β} (h : ∀ x y, x < y → f x ≠ f y) :
     Injective f := by
   intro x y hxy
@@ -702,51 +751,75 @@ theorem injective_of_lt_imp_ne [LinearOrder α] {f : α → β} (h : ∀ x y, x
   cases' Ne.lt_or_lt hxy with hxy hxy
   exacts[h _ _ hxy, (h _ _ hxy).symm]
 #align injective_of_lt_imp_ne injective_of_lt_imp_ne
--/
 
-#print injective_of_le_imp_le /-
+/- warning: injective_of_le_imp_le -> injective_of_le_imp_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β), (forall {x : α} {y : α}, (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f x) (f y)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x y)) -> (Function.Injective.{succ u1, succ u2} α β f)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] (f : α -> β), (forall {x : α} {y : α}, (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f x) (f y)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) x y)) -> (Function.Injective.{succ u1, succ u2} α β f)
+Case conversion may be inaccurate. Consider using '#align injective_of_le_imp_le injective_of_le_imp_leₓ'. -/
 theorem injective_of_le_imp_le [PartialOrder α] [Preorder β] (f : α → β)
     (h : ∀ {x y}, f x ≤ f y → x ≤ y) : Injective f := fun x y hxy => (h hxy.le).antisymm (h hxy.ge)
 #align injective_of_le_imp_le injective_of_le_imp_le
--/
 
 section Preorder
 
 variable [Preorder α] [Preorder β] {f g : α → β} {a : α}
 
-#print StrictMono.isMax_of_apply /-
+/- warning: strict_mono.is_max_of_apply -> StrictMono.isMax_of_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMax.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a)) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMax.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a)) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align strict_mono.is_max_of_apply StrictMono.isMax_of_applyₓ'. -/
 theorem StrictMono.isMax_of_apply (hf : StrictMono f) (ha : IsMax (f a)) : IsMax a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMax_iff.1 h
     (hf hb).not_isMax ha
 #align strict_mono.is_max_of_apply StrictMono.isMax_of_apply
--/
 
-#print StrictMono.isMin_of_apply /-
+/- warning: strict_mono.is_min_of_apply -> StrictMono.isMin_of_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMin.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a)) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMin.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a)) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align strict_mono.is_min_of_apply StrictMono.isMin_of_applyₓ'. -/
 theorem StrictMono.isMin_of_apply (hf : StrictMono f) (ha : IsMin (f a)) : IsMin a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMin_iff.1 h
     (hf hb).not_isMin ha
 #align strict_mono.is_min_of_apply StrictMono.isMin_of_apply
--/
 
-#print StrictAnti.isMax_of_apply /-
+/- warning: strict_anti.is_max_of_apply -> StrictAnti.isMax_of_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMin.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a)) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMin.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a)) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align strict_anti.is_max_of_apply StrictAnti.isMax_of_applyₓ'. -/
 theorem StrictAnti.isMax_of_apply (hf : StrictAnti f) (ha : IsMin (f a)) : IsMax a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMax_iff.1 h
     (hf hb).not_isMin ha
 #align strict_anti.is_max_of_apply StrictAnti.isMax_of_apply
--/
 
-#print StrictAnti.isMin_of_apply /-
+/- warning: strict_anti.is_min_of_apply -> StrictAnti.isMin_of_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMax.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a)) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {a : α}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (IsMax.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a)) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align strict_anti.is_min_of_apply StrictAnti.isMin_of_applyₓ'. -/
 theorem StrictAnti.isMin_of_apply (hf : StrictAnti f) (ha : IsMax (f a)) : IsMin a :=
   of_not_not fun h =>
     let ⟨b, hb⟩ := not_isMin_iff.1 h
     (hf hb).not_isMax ha
 #align strict_anti.is_min_of_apply StrictAnti.isMin_of_apply
--/
 
-#print StrictMono.ite' /-
+/- warning: strict_mono.ite' -> StrictMono.ite' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall {{x : α}} {{y : α}}, (p x) -> (Not (p y)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f x) (g y))) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall {{x : α}} {{y : α}}, (p x) -> (Not (p y)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f x) (g y))) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
+Case conversion may be inaccurate. Consider using '#align strict_mono.ite' StrictMono.ite'ₓ'. -/
 protected theorem StrictMono.ite' (hf : StrictMono f) (hg : StrictMono g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x)
     (hfg : ∀ ⦃x y⦄, p x → ¬p y → x < y → f x < g y) :
@@ -760,32 +833,43 @@ protected theorem StrictMono.ite' (hf : StrictMono f) (hg : StrictMono g) {p : 
   · simpa [hx, hy] using hfg hx hy h
   · simpa [hx, hy] using hg h
 #align strict_mono.ite' StrictMono.ite'
--/
 
-#print StrictMono.ite /-
+/- warning: strict_mono.ite -> StrictMono.ite is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f x) (g x)) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictMono.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall (x : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f x) (g x)) -> (StrictMono.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
+Case conversion may be inaccurate. Consider using '#align strict_mono.ite StrictMono.iteₓ'. -/
 protected theorem StrictMono.ite (hf : StrictMono f) (hg : StrictMono g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x) (hfg : ∀ x, f x ≤ g x) :
     StrictMono fun x => if p x then f x else g x :=
   hf.ite' hg hp fun x y hx hy h => (hf h).trans_le (hfg y)
 #align strict_mono.ite StrictMono.ite
--/
 
-#print StrictAnti.ite' /-
+/- warning: strict_anti.ite' -> StrictAnti.ite' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall {{x : α}} {{y : α}}, (p x) -> (Not (p y)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (g y) (f x))) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall {{x : α}} {{y : α}}, (p x) -> (Not (p y)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (g y) (f x))) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
+Case conversion may be inaccurate. Consider using '#align strict_anti.ite' StrictAnti.ite'ₓ'. -/
 protected theorem StrictAnti.ite' (hf : StrictAnti f) (hg : StrictAnti g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x)
     (hfg : ∀ ⦃x y⦄, p x → ¬p y → x < y → g y < f x) :
     StrictAnti fun x => if p x then f x else g x :=
   (StrictMono.ite' hf.dual_right hg.dual_right hp hfg).dual_right
 #align strict_anti.ite' StrictAnti.ite'
--/
 
-#print StrictAnti.ite /-
+/- warning: strict_anti.ite -> StrictAnti.ite is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall (x : α), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (g x) (f x)) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (StrictAnti.{u1, u2} α β _inst_1 _inst_2 f) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 g) -> (forall {p : α -> Prop} [_inst_3 : DecidablePred.{succ u1} α p], (forall {{x : α}} {{y : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x y) -> (p y) -> (p x)) -> (forall (x : α), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (g x) (f x)) -> (StrictAnti.{u1, u2} α β _inst_1 _inst_2 (fun (x : α) => ite.{succ u2} β (p x) (_inst_3 x) (f x) (g x))))
+Case conversion may be inaccurate. Consider using '#align strict_anti.ite StrictAnti.iteₓ'. -/
 protected theorem StrictAnti.ite (hf : StrictAnti f) (hg : StrictAnti g) {p : α → Prop}
     [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x) (hfg : ∀ x, g x ≤ f x) :
     StrictAnti fun x => if p x then f x else g x :=
   hf.ite' hg hp fun x y hx hy h => (hfg y).trans_lt (hf h)
 #align strict_anti.ite StrictAnti.ite
--/
 
 end Preorder
 
@@ -953,46 +1037,70 @@ variable [Preorder β] {f : α → β} {s : Set α}
 
 open Ordering
 
-#print Monotone.reflect_lt /-
+/- warning: monotone.reflect_lt -> Monotone.reflect_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
+Case conversion may be inaccurate. Consider using '#align monotone.reflect_lt Monotone.reflect_ltₓ'. -/
 theorem Monotone.reflect_lt (hf : Monotone f) {a b : α} (h : f a < f b) : a < b :=
   lt_of_not_ge fun h' => h.not_le (hf h')
 #align monotone.reflect_lt Monotone.reflect_lt
--/
 
-#print Antitone.reflect_lt /-
+/- warning: antitone.reflect_lt -> Antitone.reflect_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
+Case conversion may be inaccurate. Consider using '#align antitone.reflect_lt Antitone.reflect_ltₓ'. -/
 theorem Antitone.reflect_lt (hf : Antitone f) {a b : α} (h : f a < f b) : b < a :=
   lt_of_not_ge fun h' => h.not_le (hf h')
 #align antitone.reflect_lt Antitone.reflect_lt
--/
 
-#print MonotoneOn.reflect_lt /-
+/- warning: monotone_on.reflect_lt -> MonotoneOn.reflect_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
+Case conversion may be inaccurate. Consider using '#align monotone_on.reflect_lt MonotoneOn.reflect_ltₓ'. -/
 theorem MonotoneOn.reflect_lt (hf : MonotoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
     (h : f a < f b) : a < b :=
   lt_of_not_ge fun h' => h.not_le <| hf hb ha h'
 #align monotone_on.reflect_lt MonotoneOn.reflect_lt
--/
 
-#print AntitoneOn.reflect_lt /-
+/- warning: antitone_on.reflect_lt -> AntitoneOn.reflect_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
+Case conversion may be inaccurate. Consider using '#align antitone_on.reflect_lt AntitoneOn.reflect_ltₓ'. -/
 theorem AntitoneOn.reflect_lt (hf : AntitoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
     (h : f a < f b) : b < a :=
   lt_of_not_ge fun h' => h.not_le <| hf ha hb h'
 #align antitone_on.reflect_lt AntitoneOn.reflect_lt
--/
 
-#print StrictMonoOn.le_iff_le /-
+/- warning: strict_mono_on.le_iff_le -> StrictMonoOn.le_iff_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Iff (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b)))
+Case conversion may be inaccurate. Consider using '#align strict_mono_on.le_iff_le StrictMonoOn.le_iff_leₓ'. -/
 theorem StrictMonoOn.le_iff_le (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a ≤ f b ↔ a ≤ b :=
   ⟨fun h => le_of_not_gt fun h' => (hf hb ha h').not_le h, fun h =>
     h.lt_or_eq_dec.elim (fun h' => (hf ha hb h').le) fun h' => h' ▸ le_rfl⟩
 #align strict_mono_on.le_iff_le StrictMonoOn.le_iff_le
--/
 
-#print StrictAntiOn.le_iff_le /-
+/- warning: strict_anti_on.le_iff_le -> StrictAntiOn.le_iff_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Iff (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a)))
+Case conversion may be inaccurate. Consider using '#align strict_anti_on.le_iff_le StrictAntiOn.le_iff_leₓ'. -/
 theorem StrictAntiOn.le_iff_le (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a ≤ f b ↔ b ≤ a :=
   hf.dual_right.le_iff_le hb ha
 #align strict_anti_on.le_iff_le StrictAntiOn.le_iff_le
--/
 
 #print StrictMonoOn.eq_iff_eq /-
 theorem StrictMonoOn.eq_iff_eq (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
@@ -1011,45 +1119,74 @@ theorem StrictAntiOn.eq_iff_eq (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s)
 #align strict_anti_on.eq_iff_eq StrictAntiOn.eq_iff_eq
 -/
 
-#print StrictMonoOn.lt_iff_lt /-
+/- warning: strict_mono_on.lt_iff_lt -> StrictMonoOn.lt_iff_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Iff (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Iff (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b)))
+Case conversion may be inaccurate. Consider using '#align strict_mono_on.lt_iff_lt StrictMonoOn.lt_iff_ltₓ'. -/
 theorem StrictMonoOn.lt_iff_lt (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a < f b ↔ a < b := by
   rw [lt_iff_le_not_le, lt_iff_le_not_le, hf.le_iff_le ha hb, hf.le_iff_le hb ha]
 #align strict_mono_on.lt_iff_lt StrictMonoOn.lt_iff_lt
--/
 
-#print StrictAntiOn.lt_iff_lt /-
+/- warning: strict_anti_on.lt_iff_lt -> StrictAntiOn.lt_iff_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Iff (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Iff (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a)))
+Case conversion may be inaccurate. Consider using '#align strict_anti_on.lt_iff_lt StrictAntiOn.lt_iff_ltₓ'. -/
 theorem StrictAntiOn.lt_iff_lt (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
     f a < f b ↔ b < a :=
   hf.dual_right.lt_iff_lt hb ha
 #align strict_anti_on.lt_iff_lt StrictAntiOn.lt_iff_lt
--/
 
-#print StrictMono.le_iff_le /-
+/- warning: strict_mono.le_iff_le -> StrictMono.le_iff_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
+Case conversion may be inaccurate. Consider using '#align strict_mono.le_iff_le StrictMono.le_iff_leₓ'. -/
 theorem StrictMono.le_iff_le (hf : StrictMono f) {a b : α} : f a ≤ f b ↔ a ≤ b :=
   (hf.StrictMonoOn Set.univ).le_iff_le trivial trivial
 #align strict_mono.le_iff_le StrictMono.le_iff_le
--/
 
-#print StrictAnti.le_iff_le /-
+/- warning: strict_anti.le_iff_le -> StrictAnti.le_iff_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) (f b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
+Case conversion may be inaccurate. Consider using '#align strict_anti.le_iff_le StrictAnti.le_iff_leₓ'. -/
 theorem StrictAnti.le_iff_le (hf : StrictAnti f) {a b : α} : f a ≤ f b ↔ b ≤ a :=
   (hf.StrictAntiOn Set.univ).le_iff_le trivial trivial
 #align strict_anti.le_iff_le StrictAnti.le_iff_le
--/
 
-#print StrictMono.lt_iff_lt /-
+/- warning: strict_mono.lt_iff_lt -> StrictMono.lt_iff_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b))
+Case conversion may be inaccurate. Consider using '#align strict_mono.lt_iff_lt StrictMono.lt_iff_ltₓ'. -/
 theorem StrictMono.lt_iff_lt (hf : StrictMono f) {a b : α} : f a < f b ↔ a < b :=
   (hf.StrictMonoOn Set.univ).lt_iff_lt trivial trivial
 #align strict_mono.lt_iff_lt StrictMono.lt_iff_lt
--/
 
-#print StrictAnti.lt_iff_lt /-
+/- warning: strict_anti.lt_iff_lt -> StrictAnti.lt_iff_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α}, Iff (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (f a) (f b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b a))
+Case conversion may be inaccurate. Consider using '#align strict_anti.lt_iff_lt StrictAnti.lt_iff_ltₓ'. -/
 theorem StrictAnti.lt_iff_lt (hf : StrictAnti f) {a b : α} : f a < f b ↔ b < a :=
   (hf.StrictAntiOn Set.univ).lt_iff_lt trivial trivial
 #align strict_anti.lt_iff_lt StrictAnti.lt_iff_lt
--/
 
-#print StrictMonoOn.compares /-
+/- warning: strict_mono_on.compares -> StrictMonoOn.compares is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (forall {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (forall {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toLT.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b)))
+Case conversion may be inaccurate. Consider using '#align strict_mono_on.compares StrictMonoOn.comparesₓ'. -/
 protected theorem StrictMonoOn.compares (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s)
     (hb : b ∈ s) : ∀ {o : Ordering}, o.Compares (f a) (f b) ↔ o.Compares a b
   | Ordering.lt => hf.lt_iff_lt ha hb
@@ -1058,28 +1195,39 @@ protected theorem StrictMonoOn.compares (hf : StrictMonoOn f s) {a b : α} (ha :
       congr_arg _⟩
   | Ordering.gt => hf.lt_iff_lt hb ha
 #align strict_mono_on.compares StrictMonoOn.compares
--/
 
-#print StrictAntiOn.compares /-
+/- warning: strict_anti_on.compares -> StrictAntiOn.compares is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (forall {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o b a)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f s) -> (forall {a : α} {b : α}, (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (forall {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toLT.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o b a)))
+Case conversion may be inaccurate. Consider using '#align strict_anti_on.compares StrictAntiOn.comparesₓ'. -/
 protected theorem StrictAntiOn.compares (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
     {o : Ordering} : o.Compares (f a) (f b) ↔ o.Compares b a :=
   toDual_compares_toDual.trans <| hf.dual_right.Compares hb ha
 #align strict_anti_on.compares StrictAntiOn.compares
--/
 
-#print StrictMono.compares /-
+/- warning: strict_mono.compares -> StrictMono.compares is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α} {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α} {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toLT.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b))
+Case conversion may be inaccurate. Consider using '#align strict_mono.compares StrictMono.comparesₓ'. -/
 protected theorem StrictMono.compares (hf : StrictMono f) {a b : α} {o : Ordering} :
     o.Compares (f a) (f b) ↔ o.Compares a b :=
   (hf.StrictMonoOn Set.univ).Compares trivial trivial
 #align strict_mono.compares StrictMono.compares
--/
 
-#print StrictAnti.compares /-
+/- warning: strict_anti.compares -> StrictAnti.compares is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α} {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o b a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α} {b : α} {o : Ordering}, Iff (Ordering.Compares.{u2} β (Preorder.toLT.{u2} β _inst_2) o (f a) (f b)) (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o b a))
+Case conversion may be inaccurate. Consider using '#align strict_anti.compares StrictAnti.comparesₓ'. -/
 protected theorem StrictAnti.compares (hf : StrictAnti f) {a b : α} {o : Ordering} :
     o.Compares (f a) (f b) ↔ o.Compares b a :=
   (hf.StrictAntiOn Set.univ).Compares trivial trivial
 #align strict_anti.compares StrictAnti.compares
--/
 
 #print StrictMono.injective /-
 theorem StrictMono.injective (hf : StrictMono f) : Injective f := fun x y h =>
@@ -1093,33 +1241,49 @@ theorem StrictAnti.injective (hf : StrictAnti f) : Injective f := fun x y h =>
 #align strict_anti.injective StrictAnti.injective
 -/
 
-#print StrictMono.maximal_of_maximal_image /-
+/- warning: strict_mono.maximal_of_maximal_image -> StrictMono.maximal_of_maximal_image is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) p (f a)) -> (forall (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) p (f a)) -> (forall (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x a))
+Case conversion may be inaccurate. Consider using '#align strict_mono.maximal_of_maximal_image StrictMono.maximal_of_maximal_imageₓ'. -/
 theorem StrictMono.maximal_of_maximal_image (hf : StrictMono f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
     x ≤ a :=
   hf.le_iff_le.mp (hmax (f x))
 #align strict_mono.maximal_of_maximal_image StrictMono.maximal_of_maximal_image
--/
 
-#print StrictMono.minimal_of_minimal_image /-
+/- warning: strict_mono.minimal_of_minimal_image -> StrictMono.minimal_of_minimal_image is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) p) -> (forall (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictMono.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) p) -> (forall (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a x))
+Case conversion may be inaccurate. Consider using '#align strict_mono.minimal_of_minimal_image StrictMono.minimal_of_minimal_imageₓ'. -/
 theorem StrictMono.minimal_of_minimal_image (hf : StrictMono f) {a} (hmin : ∀ p, f a ≤ p) (x : α) :
     a ≤ x :=
   hf.le_iff_le.mp (hmin (f x))
 #align strict_mono.minimal_of_minimal_image StrictMono.minimal_of_minimal_image
--/
 
-#print StrictAnti.minimal_of_maximal_image /-
+/- warning: strict_anti.minimal_of_maximal_image -> StrictAnti.minimal_of_maximal_image is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) p (f a)) -> (forall (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a x))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) p (f a)) -> (forall (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a x))
+Case conversion may be inaccurate. Consider using '#align strict_anti.minimal_of_maximal_image StrictAnti.minimal_of_maximal_imageₓ'. -/
 theorem StrictAnti.minimal_of_maximal_image (hf : StrictAnti f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
     a ≤ x :=
   hf.le_iff_le.mp (hmax (f x))
 #align strict_anti.minimal_of_maximal_image StrictAnti.minimal_of_maximal_image
--/
 
-#print StrictAnti.maximal_of_minimal_image /-
+/- warning: strict_anti.maximal_of_minimal_image -> StrictAnti.maximal_of_minimal_image is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (f a) p) -> (forall (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x a))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (StrictAnti.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) _inst_2 f) -> (forall {a : α}, (forall (p : β), LE.le.{u2} β (Preorder.toLE.{u2} β _inst_2) (f a) p) -> (forall (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x a))
+Case conversion may be inaccurate. Consider using '#align strict_anti.maximal_of_minimal_image StrictAnti.maximal_of_minimal_imageₓ'. -/
 theorem StrictAnti.maximal_of_minimal_image (hf : StrictAnti f) {a} (hmin : ∀ p, f a ≤ p) (x : α) :
     x ≤ a :=
   hf.le_iff_le.mp (hmin (f x))
 #align strict_anti.maximal_of_minimal_image StrictAnti.maximal_of_minimal_image
--/
 
 end Preorder
 
@@ -1143,7 +1307,12 @@ end PartialOrder
 
 variable [LinearOrder β] {f : α → β} {s : Set α} {x y : α}
 
-#print not_monotone_not_antitone_iff_exists_le_le /-
+/- warning: not_monotone_not_antitone_iff_exists_le_le -> not_monotone_not_antitone_iff_exists_le_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, Iff (And (Not (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f)) (Not (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f))) (Exists.{succ u1} α (fun (a : α) => Exists.{succ u1} α (fun (b : α) => Exists.{succ u1} α (fun (c : α) => And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b) (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b c) (Or (And (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f a) (f b)) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f c) (f b))) (And (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f a)) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f c)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, Iff (And (Not (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f)) (Not (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f))) (Exists.{succ u1} α (fun (a : α) => Exists.{succ u1} α (fun (b : α) => Exists.{succ u1} α (fun (c : α) => And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b) (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b c) (Or (And (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f a) (f b)) (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f c) (f b))) (And (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f a)) (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f c)))))))))
+Case conversion may be inaccurate. Consider using '#align not_monotone_not_antitone_iff_exists_le_le not_monotone_not_antitone_iff_exists_le_leₓ'. -/
 /-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
 downright. -/
 theorem not_monotone_not_antitone_iff_exists_le_le :
@@ -1175,9 +1344,13 @@ theorem not_monotone_not_antitone_iff_exists_le_le :
     · exact ⟨a, b, d, hab, hbd, Or.inr ⟨hfba, hfbd⟩⟩
     · exact ⟨a, d, b, had, hdb, Or.inl ⟨hfac.trans_lt hfcd, hfbd⟩⟩
 #align not_monotone_not_antitone_iff_exists_le_le not_monotone_not_antitone_iff_exists_le_le
--/
 
-#print not_monotone_not_antitone_iff_exists_lt_lt /-
+/- warning: not_monotone_not_antitone_iff_exists_lt_lt -> not_monotone_not_antitone_iff_exists_lt_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, Iff (And (Not (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f)) (Not (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f))) (Exists.{succ u1} α (fun (a : α) => Exists.{succ u1} α (fun (b : α) => Exists.{succ u1} α (fun (c : α) => And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b) (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b c) (Or (And (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f a) (f b)) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f c) (f b))) (And (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f a)) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f c)))))))))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, Iff (And (Not (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f)) (Not (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2)) f))) (Exists.{succ u1} α (fun (a : α) => Exists.{succ u1} α (fun (b : α) => Exists.{succ u1} α (fun (c : α) => And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) a b) (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) b c) (Or (And (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f a) (f b)) (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f c) (f b))) (And (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f a)) (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (f b) (f c)))))))))
+Case conversion may be inaccurate. Consider using '#align not_monotone_not_antitone_iff_exists_lt_lt not_monotone_not_antitone_iff_exists_lt_ltₓ'. -/
 /-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
 downright. -/
 theorem not_monotone_not_antitone_iff_exists_lt_lt :
@@ -1191,7 +1364,6 @@ theorem not_monotone_not_antitone_iff_exists_lt_lt :
       rintro rfl <;>
     simpa using h
 #align not_monotone_not_antitone_iff_exists_lt_lt not_monotone_not_antitone_iff_exists_lt_lt
--/
 
 /-!
 ### Strictly monotone functions and `cmp`
@@ -1264,33 +1436,54 @@ theorem Nat.rel_of_forall_rel_succ_of_le (r : β → β → Prop) [IsRefl β r]
 #align nat.rel_of_forall_rel_succ_of_le Nat.rel_of_forall_rel_succ_of_le
 -/
 
-#print monotone_nat_of_le_succ /-
+/- warning: monotone_nat_of_le_succ -> monotone_nat_of_le_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))) -> (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))) -> (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+Case conversion may be inaccurate. Consider using '#align monotone_nat_of_le_succ monotone_nat_of_le_succₓ'. -/
 theorem monotone_nat_of_le_succ {f : ℕ → α} (hf : ∀ n, f n ≤ f (n + 1)) : Monotone f :=
   Nat.rel_of_forall_rel_succ_of_le (· ≤ ·) hf
 #align monotone_nat_of_le_succ monotone_nat_of_le_succ
--/
 
-#print antitone_nat_of_succ_le /-
+/- warning: antitone_nat_of_succ_le -> antitone_nat_of_succ_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f n)) -> (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f n)) -> (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+Case conversion may be inaccurate. Consider using '#align antitone_nat_of_succ_le antitone_nat_of_succ_leₓ'. -/
 theorem antitone_nat_of_succ_le {f : ℕ → α} (hf : ∀ n, f (n + 1) ≤ f n) : Antitone f :=
   @monotone_nat_of_le_succ αᵒᵈ _ _ hf
 #align antitone_nat_of_succ_le antitone_nat_of_succ_le
--/
 
-#print strictMono_nat_of_lt_succ /-
+/- warning: strict_mono_nat_of_lt_succ -> strictMono_nat_of_lt_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))) -> (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))) -> (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+Case conversion may be inaccurate. Consider using '#align strict_mono_nat_of_lt_succ strictMono_nat_of_lt_succₓ'. -/
 theorem strictMono_nat_of_lt_succ {f : ℕ → α} (hf : ∀ n, f n < f (n + 1)) : StrictMono f :=
   Nat.rel_of_forall_rel_succ_of_lt (· < ·) hf
 #align strict_mono_nat_of_lt_succ strictMono_nat_of_lt_succ
--/
 
-#print strictAnti_nat_of_succ_lt /-
+/- warning: strict_anti_nat_of_succ_lt -> strictAnti_nat_of_succ_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) (f n)) -> (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (forall (n : Nat), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) (f n)) -> (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+Case conversion may be inaccurate. Consider using '#align strict_anti_nat_of_succ_lt strictAnti_nat_of_succ_ltₓ'. -/
 theorem strictAnti_nat_of_succ_lt {f : ℕ → α} (hf : ∀ n, f (n + 1) < f n) : StrictAnti f :=
   @strictMono_nat_of_lt_succ αᵒᵈ _ f hf
 #align strict_anti_nat_of_succ_lt strictAnti_nat_of_succ_lt
--/
 
 namespace Nat
 
-#print Nat.exists_strictMono' /-
+/- warning: nat.exists_strict_mono' -> Nat.exists_strictMono' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => And (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) (Eq.{succ u1} α (f (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => And (StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) (Eq.{succ u1} α (f (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) a))
+Case conversion may be inaccurate. Consider using '#align nat.exists_strict_mono' Nat.exists_strictMono'ₓ'. -/
 /-- If `α` is a preorder with no maximal elements, then there exists a strictly monotone function
 `ℕ → α` with any prescribed value of `f 0`. -/
 theorem exists_strictMono' [NoMaxOrder α] (a : α) : ∃ f : ℕ → α, StrictMono f ∧ f 0 = a :=
@@ -1299,19 +1492,27 @@ theorem exists_strictMono' [NoMaxOrder α] (a : α) : ∃ f : ℕ → α, Strict
   choose g hg
   exact ⟨fun n => Nat.recOn n a fun _ => g, strictMono_nat_of_lt_succ fun n => hg _, rfl⟩
 #align nat.exists_strict_mono' Nat.exists_strictMono'
--/
 
-#print Nat.exists_strictAnti' /-
+/- warning: nat.exists_strict_anti' -> Nat.exists_strictAnti' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => And (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) (Eq.{succ u1} α (f (OfNat.ofNat.{0} Nat 0 (OfNat.mk.{0} Nat 0 (Zero.zero.{0} Nat Nat.hasZero)))) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => And (StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) (Eq.{succ u1} α (f (OfNat.ofNat.{0} Nat 0 (instOfNatNat 0))) a))
+Case conversion may be inaccurate. Consider using '#align nat.exists_strict_anti' Nat.exists_strictAnti'ₓ'. -/
 /-- If `α` is a preorder with no maximal elements, then there exists a strictly antitone function
 `ℕ → α` with any prescribed value of `f 0`. -/
 theorem exists_strictAnti' [NoMinOrder α] (a : α) : ∃ f : ℕ → α, StrictAnti f ∧ f 0 = a :=
   exists_strictMono' (OrderDual.toDual a)
 #align nat.exists_strict_anti' Nat.exists_strictAnti'
--/
 
 variable (α)
 
-#print Nat.exists_strictMono /-
+/- warning: nat.exists_strict_mono -> Nat.exists_strictMono is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+but is expected to have type
+  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => StrictMono.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+Case conversion may be inaccurate. Consider using '#align nat.exists_strict_mono Nat.exists_strictMonoₓ'. -/
 /-- If `α` is a nonempty preorder with no maximal elements, then there exists a strictly monotone
 function `ℕ → α`. -/
 theorem exists_strictMono [Nonempty α] [NoMaxOrder α] : ∃ f : ℕ → α, StrictMono f :=
@@ -1319,15 +1520,18 @@ theorem exists_strictMono [Nonempty α] [NoMaxOrder α] : ∃ f : ℕ → α, St
   let ⟨f, hf, hfa⟩ := exists_strictMono' a
   ⟨f, hf⟩
 #align nat.exists_strict_mono Nat.exists_strictMono
--/
 
-#print Nat.exists_strictAnti /-
+/- warning: nat.exists_strict_anti -> Nat.exists_strictAnti is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+but is expected to have type
+  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Exists.{succ u1} (Nat -> α) (fun (f : Nat -> α) => StrictAnti.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f)
+Case conversion may be inaccurate. Consider using '#align nat.exists_strict_anti Nat.exists_strictAntiₓ'. -/
 /-- If `α` is a nonempty preorder with no minimal elements, then there exists a strictly antitone
 function `ℕ → α`. -/
 theorem exists_strictAnti [Nonempty α] [NoMinOrder α] : ∃ f : ℕ → α, StrictAnti f :=
   exists_strictMono αᵒᵈ
 #align nat.exists_strict_anti Nat.exists_strictAnti
--/
 
 end Nat
 
@@ -1353,7 +1557,7 @@ theorem Int.rel_of_forall_rel_succ_of_le (r : β → β → Prop) [IsRefl β r]
 
 /- warning: monotone_int_of_le_succ -> monotone_int_of_le_succ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))))) -> (Monotone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))))) -> (Monotone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))))) -> (Monotone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
 Case conversion may be inaccurate. Consider using '#align monotone_int_of_le_succ monotone_int_of_le_succₓ'. -/
@@ -1363,7 +1567,7 @@ theorem monotone_int_of_le_succ {f : ℤ → α} (hf : ∀ n, f n ≤ f (n + 1))
 
 /- warning: antitone_int_of_succ_le -> antitone_int_of_succ_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) (f n)) -> (Antitone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) (f n)) -> (Antitone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) (f n)) -> (Antitone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
 Case conversion may be inaccurate. Consider using '#align antitone_int_of_succ_le antitone_int_of_succ_leₓ'. -/
@@ -1373,7 +1577,7 @@ theorem antitone_int_of_succ_le {f : ℤ → α} (hf : ∀ n, f (n + 1) ≤ f n)
 
 /- warning: strict_mono_int_of_lt_succ -> strictMono_int_of_lt_succ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))))) -> (StrictMono.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))))) -> (StrictMono.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f n) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))))) -> (StrictMono.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
 Case conversion may be inaccurate. Consider using '#align strict_mono_int_of_lt_succ strictMono_int_of_lt_succₓ'. -/
@@ -1383,7 +1587,7 @@ theorem strictMono_int_of_lt_succ {f : ℤ → α} (hf : ∀ n, f n < f (n + 1))
 
 /- warning: strict_anti_int_of_succ_lt -> strictAnti_int_of_succ_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) (f n)) -> (StrictAnti.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) (f n)) -> (StrictAnti.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (forall (n : Int), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) (f n)) -> (StrictAnti.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
 Case conversion may be inaccurate. Consider using '#align strict_anti_int_of_succ_lt strictAnti_int_of_succ_ltₓ'. -/
@@ -1397,7 +1601,7 @@ variable (α) [Nonempty α] [NoMinOrder α] [NoMaxOrder α]
 
 /- warning: int.exists_strict_mono -> Int.exists_strictMono is a dubious translation:
 lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Exists.{succ u1} (Int -> α) (fun (f : Int -> α) => StrictMono.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
+  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Exists.{succ u1} (Int -> α) (fun (f : Int -> α) => StrictMono.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Exists.{succ u1} (Int -> α) (fun (f : Int -> α) => StrictMono.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
 Case conversion may be inaccurate. Consider using '#align int.exists_strict_mono Int.exists_strictMonoₓ'. -/
@@ -1419,7 +1623,7 @@ theorem exists_strictMono : ∃ f : ℤ → α, StrictMono f :=
 
 /- warning: int.exists_strict_anti -> Int.exists_strictAnti is a dubious translation:
 lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Exists.{succ u1} (Int -> α) (fun (f : Int -> α) => StrictAnti.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
+  forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Exists.{succ u1} (Int -> α) (fun (f : Int -> α) => StrictAnti.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f)
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : Preorder.{u1} α] [_inst_2 : Nonempty.{succ u1} α] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Exists.{succ u1} (Int -> α) (fun (f : Int -> α) => StrictAnti.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f)
 Case conversion may be inaccurate. Consider using '#align int.exists_strict_anti Int.exists_strictAntiₓ'. -/
@@ -1431,7 +1635,12 @@ theorem exists_strictAnti : ∃ f : ℤ → α, StrictAnti f :=
 
 end Int
 
-#print Monotone.ne_of_lt_of_lt_nat /-
+/- warning: monotone.ne_of_lt_of_lt_nat -> Monotone.ne_of_lt_of_lt_nat is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) -> (forall (n : Nat) {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f n) x) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))))) -> (forall (a : Nat), Ne.{succ u1} α (f a) x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (Monotone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) -> (forall (n : Nat) {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f n) x) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))))) -> (forall (a : Nat), Ne.{succ u1} α (f a) x))
+Case conversion may be inaccurate. Consider using '#align monotone.ne_of_lt_of_lt_nat Monotone.ne_of_lt_of_lt_natₓ'. -/
 -- TODO@Yael: Generalize the following four to succ orders
 /-- If `f` is a monotone function from `ℕ` to a preorder such that `x` lies between `f n` and
   `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/
@@ -1441,9 +1650,13 @@ theorem Monotone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Monotone f) (n : ℕ)
   rintro rfl
   exact (hf.reflect_lt h1).not_le (Nat.le_of_lt_succ <| hf.reflect_lt h2)
 #align monotone.ne_of_lt_of_lt_nat Monotone.ne_of_lt_of_lt_nat
--/
 
-#print Antitone.ne_of_lt_of_lt_nat /-
+/- warning: antitone.ne_of_lt_of_lt_nat -> Antitone.ne_of_lt_of_lt_nat is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) -> (forall (n : Nat) {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))))) x) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x (f n)) -> (forall (a : Nat), Ne.{succ u1} α (f a) x))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Nat -> α}, (Antitone.{0, u1} Nat α (PartialOrder.toPreorder.{0} Nat (LinearOrder.toPartialOrder.{0} Nat Nat.linearOrder)) _inst_1 f) -> (forall (n : Nat) {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)))) x) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f n)) -> (forall (a : Nat), Ne.{succ u1} α (f a) x))
+Case conversion may be inaccurate. Consider using '#align antitone.ne_of_lt_of_lt_nat Antitone.ne_of_lt_of_lt_natₓ'. -/
 /-- If `f` is an antitone function from `ℕ` to a preorder such that `x` lies between `f (n + 1)` and
 `f n`, then `x` doesn't lie in the range of `f`. -/
 theorem Antitone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Antitone f) (n : ℕ) {x : α}
@@ -1452,11 +1665,10 @@ theorem Antitone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Antitone f) (n : ℕ)
   rintro rfl
   exact (hf.reflect_lt h2).not_le (Nat.le_of_lt_succ <| hf.reflect_lt h1)
 #align antitone.ne_of_lt_of_lt_nat Antitone.ne_of_lt_of_lt_nat
--/
 
 /- warning: monotone.ne_of_lt_of_lt_int -> Monotone.ne_of_lt_of_lt_int is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (Monotone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f) -> (forall (n : Int) {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f n) x) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))))) -> (forall (a : Int), Ne.{succ u1} α (f a) x))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (Monotone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f) -> (forall (n : Int) {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f n) x) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))))) -> (forall (a : Int), Ne.{succ u1} α (f a) x))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (Monotone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f) -> (forall (n : Int) {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f n) x) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))))) -> (forall (a : Int), Ne.{succ u1} α (f a) x))
 Case conversion may be inaccurate. Consider using '#align monotone.ne_of_lt_of_lt_int Monotone.ne_of_lt_of_lt_intₓ'. -/
@@ -1471,7 +1683,7 @@ theorem Monotone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Monotone f) (n : ℤ)
 
 /- warning: antitone.ne_of_lt_of_lt_int -> Antitone.ne_of_lt_of_lt_int is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (Antitone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f) -> (forall (n : Int) {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) x) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f n)) -> (forall (a : Int), Ne.{succ u1} α (f a) x))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (Antitone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.linearOrder)) _inst_1 f) -> (forall (n : Int) {x : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.hasAdd) n (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) x) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) x (f n)) -> (forall (a : Int), Ne.{succ u1} α (f a) x))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {f : Int -> α}, (Antitone.{0, u1} Int α (PartialOrder.toPreorder.{0} Int (LinearOrder.toPartialOrder.{0} Int Int.instLinearOrderInt)) _inst_1 f) -> (forall (n : Int) {x : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (f (HAdd.hAdd.{0, 0, 0} Int Int Int (instHAdd.{0} Int Int.instAddInt) n (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) x) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x (f n)) -> (forall (a : Int), Ne.{succ u1} α (f a) x))
 Case conversion may be inaccurate. Consider using '#align antitone.ne_of_lt_of_lt_int Antitone.ne_of_lt_of_lt_intₓ'. -/

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

@@ -1584,11 +1584,15 @@ namespace Function
 
 variable [Preorder α] [DecidableEq ι] [∀ i, Preorder (π i)] {f : ∀ i, π i} {i : ι}
 
+#print Function.update_mono /-
 theorem update_mono : Monotone (f.update i) := fun a b => update_le_update_iff'.2
 #align function.update_mono Function.update_mono
+-/
 
+#print Function.update_strictMono /-
 theorem update_strictMono : StrictMono (f.update i) := fun a b => update_lt_update_iff.2
 #align function.update_strict_mono Function.update_strictMono
+-/
 
 #print Function.const_mono /-
 theorem const_mono : Monotone (const β : α → β → α) := fun a b h i => h

mathlib commit https://github.com/leanprover-community/mathlib/commit/52932b3a083d4142e78a15dc928084a22fea9ba0

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Mario Carneiro, Yaël Dillies
 
 ! This file was ported from Lean 3 source module order.monotone.basic
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
+! leanprover-community/mathlib commit 90df25ded755a2cf9651ea850d1abe429b1e4eb1
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -69,7 +69,8 @@ open Function OrderDual
 
 universe u v w
 
-variable {α : Type u} {β : Type v} {γ : Type w} {δ : Type _} {r : α → α → Prop}
+variable {ι : Type _} {α : Type u} {β : Type v} {γ : Type w} {δ : Type _} {π : ι → Type _}
+  {r : α → α → Prop}
 
 section MonotoneDef
 
@@ -1576,9 +1577,18 @@ theorem StrictAnti.prod_map (hf : StrictAnti f) (hg : StrictAnti g) : StrictAnti
 
 end PartialOrder
 
+/-! ### Pi types -/
+
+
 namespace Function
 
-variable [Preorder α]
+variable [Preorder α] [DecidableEq ι] [∀ i, Preorder (π i)] {f : ∀ i, π i} {i : ι}
+
+theorem update_mono : Monotone (f.update i) := fun a b => update_le_update_iff'.2
+#align function.update_mono Function.update_mono
+
+theorem update_strictMono : StrictMono (f.update i) := fun a b => update_lt_update_iff.2
+#align function.update_strict_mono Function.update_strictMono
 
 #print Function.const_mono /-
 theorem const_mono : Monotone (const β : α → β → α) := fun a b h i => h

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

Define ordinal approximants for the least/greatest fixed points of a monotone function in a complete lattice. It is sometimes also called the constructive Knaster-Tarski Theorem, first introduced by Cousot & Cousot in 1979. This implementation is however not constructive.

This has a variety of applications in non standard logics and proofs such as quantitative logics or cyclic proofs.

Co-authored-by: Ira Fesefeldt <public@feuervogel.me>

@@ -919,6 +919,20 @@ theorem Antitone.strictAnti_iff_injective (hf : Antitone f) : StrictAnti f ↔ I
   ⟨fun h ↦ h.injective, hf.strictAnti_of_injective⟩
 #align antitone.strict_anti_iff_injective Antitone.strictAnti_iff_injective
 
+/-- If a monotone function is equal at two points, it is equal between all of them -/
+theorem Monotone.eq_of_le_of_le {a₁ a₂ : α} (h_mon : Monotone f) (h_fa : f a₁ = f a₂) {i : α}
+    (h₁ : a₁ ≤ i) (h₂ : i ≤ a₂) : f i = f a₁ := by
+  apply le_antisymm
+  · rw [h_fa]; exact h_mon h₂
+  · exact h_mon h₁
+
+/-- If an antitone function is equal at two points, it is equal between all of them -/
+theorem Antitone.eq_of_le_of_le {a₁ a₂ : α} (h_anti : Antitone f) (h_fa : f a₁ = f a₂) {i : α}
+    (h₁ : a₁ ≤ i) (h₂ : i ≤ a₂) : f i = f a₁ := by
+  apply le_antisymm
+  · exact h_anti h₁
+  · rw [h_fa]; exact h_anti h₂
+
 end PartialOrder
 
 variable [LinearOrder β] {f : α → β} {s : Set α} {x y : α}

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