data.set.intervals.monotone | Mathlib porting status

Changes since the initial port

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

Changes in mathlib3

4d06b17a

(last sync)

chore(data/set/intervals/monotone): fix names (#18924)

Some lemmas used Iic instead of Ici in the names, probably because of a copy+paste error.

Diff

@@ -182,7 +182,7 @@ begin
   { exact ih (strict_mono_on.mono hφ (λ x hx, le_trans hx (le_succ _))) _ h }
 end
 
-lemma strict_mono_on.Iic_le_id [pred_order α] [is_pred_archimedean α] [order_top α]
+lemma strict_mono_on.Ici_le_id [pred_order α] [is_pred_archimedean α] [order_top α]
   {n : α} {φ : α → α} (hφ : strict_mono_on φ (set.Ici n)) :
   ∀ m, n ≤ m → φ m ≤ m :=
 @strict_mono_on.Iic_id_le αᵒᵈ _ _ _ _ _ _ (λ i hi j hj hij, hφ hj hi hij)
@@ -221,12 +221,12 @@ lemma strict_anti_on_Iic_of_succ_lt [succ_order α] [is_succ_archimedean α]
   strict_anti_on ψ (set.Iic n) :=
 λ i hi j hj hij, @strict_mono_on_Iic_of_lt_succ α βᵒᵈ _ _ ψ _ _ n hψ i hi j hj hij
 
-lemma strict_mono_on_Iic_of_pred_lt [pred_order α] [is_pred_archimedean α]
+lemma strict_mono_on_Ici_of_pred_lt [pred_order α] [is_pred_archimedean α]
   {n : α} (hψ : ∀ m, n < m → ψ (pred m) < ψ m) :
   strict_mono_on ψ (set.Ici n) :=
 λ i hi j hj hij, @strict_mono_on_Iic_of_lt_succ αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij
 
-lemma strict_anti_on_Iic_of_lt_pred [pred_order α] [is_pred_archimedean α]
+lemma strict_anti_on_Ici_of_lt_pred [pred_order α] [is_pred_archimedean α]
   {n : α} (hψ : ∀ m, n < m → ψ m < ψ (pred m)) :
   strict_anti_on ψ (set.Ici n) :=
 λ i hi j hj hij, @strict_anti_on_Iic_of_succ_lt αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij

9aba7801

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

4d06b17a

bump to nightly-2024-04-26-08

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

ab3b6a0f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2021 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
-import Data.Set.Intervals.Disjoint
+import Order.Interval.Set.Disjoint
 import Order.SuccPred.Basic
 
 #align_import data.set.intervals.monotone from "leanprover-community/mathlib"@"4d06b17aea8cf2e220f0b0aa46cd0231593c5c97"

4d06b17a

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -287,7 +287,7 @@ theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot 
       (fun _ _ hm => hm.trans bot_le) _ _
   rintro k ih hφ m hm
   by_cases hk : IsMax k
-  · rw [succ_eq_iff_is_max.2 hk] at hm 
+  · rw [succ_eq_iff_is_max.2 hk] at hm
     exact ih (hφ.mono <| Iic_subset_Iic.2 (le_succ _)) _ hm
   obtain rfl | h := le_succ_iff_eq_or_le.1 hm
   · specialize ih (StrictMonoOn.mono hφ fun x hx => le_trans hx (le_succ _)) k le_rfl

4d06b17a

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2021 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
-import Mathbin.Data.Set.Intervals.Disjoint
-import Mathbin.Order.SuccPred.Basic
+import Data.Set.Intervals.Disjoint
+import Order.SuccPred.Basic
 
 #align_import data.set.intervals.monotone from "leanprover-community/mathlib"@"4d06b17aea8cf2e220f0b0aa46cd0231593c5c97"

4d06b17a

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module data.set.intervals.monotone
-! leanprover-community/mathlib commit 4d06b17aea8cf2e220f0b0aa46cd0231593c5c97
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Intervals.Disjoint
 import Mathbin.Order.SuccPred.Basic
 
+#align_import data.set.intervals.monotone from "leanprover-community/mathlib"@"4d06b17aea8cf2e220f0b0aa46cd0231593c5c97"
+
 /-!
 # Monotonicity on intervals

4d06b17a

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -28,161 +28,233 @@ section Ixx
 
 variable {α β : Type _} [Preorder α] [Preorder β] {f g : α → β} {s : Set α}
 
+#print antitone_Ici /-
 theorem antitone_Ici : Antitone (Ici : α → Set α) := fun _ _ => Ici_subset_Ici.2
 #align antitone_Ici antitone_Ici
+-/
 
+#print monotone_Iic /-
 theorem monotone_Iic : Monotone (Iic : α → Set α) := fun _ _ => Iic_subset_Iic.2
 #align monotone_Iic monotone_Iic
+-/
 
+#print antitone_Ioi /-
 theorem antitone_Ioi : Antitone (Ioi : α → Set α) := fun _ _ => Ioi_subset_Ioi
 #align antitone_Ioi antitone_Ioi
+-/
 
+#print monotone_Iio /-
 theorem monotone_Iio : Monotone (Iio : α → Set α) := fun _ _ => Iio_subset_Iio
 #align monotone_Iio monotone_Iio
+-/
 
+#print Monotone.Ici /-
 protected theorem Monotone.Ici (hf : Monotone f) : Antitone fun x => Ici (f x) :=
   antitone_Ici.comp_monotone hf
 #align monotone.Ici Monotone.Ici
+-/
 
+#print MonotoneOn.Ici /-
 protected theorem MonotoneOn.Ici (hf : MonotoneOn f s) : AntitoneOn (fun x => Ici (f x)) s :=
   antitone_Ici.comp_monotoneOn hf
 #align monotone_on.Ici MonotoneOn.Ici
+-/
 
+#print Antitone.Ici /-
 protected theorem Antitone.Ici (hf : Antitone f) : Monotone fun x => Ici (f x) :=
   antitone_Ici.comp hf
 #align antitone.Ici Antitone.Ici
+-/
 
+#print AntitoneOn.Ici /-
 protected theorem AntitoneOn.Ici (hf : AntitoneOn f s) : MonotoneOn (fun x => Ici (f x)) s :=
   antitone_Ici.comp_antitoneOn hf
 #align antitone_on.Ici AntitoneOn.Ici
+-/
 
+#print Monotone.Iic /-
 protected theorem Monotone.Iic (hf : Monotone f) : Monotone fun x => Iic (f x) :=
   monotone_Iic.comp hf
 #align monotone.Iic Monotone.Iic
+-/
 
+#print MonotoneOn.Iic /-
 protected theorem MonotoneOn.Iic (hf : MonotoneOn f s) : MonotoneOn (fun x => Iic (f x)) s :=
   monotone_Iic.comp_monotoneOn hf
 #align monotone_on.Iic MonotoneOn.Iic
+-/
 
+#print Antitone.Iic /-
 protected theorem Antitone.Iic (hf : Antitone f) : Antitone fun x => Iic (f x) :=
   monotone_Iic.comp_antitone hf
 #align antitone.Iic Antitone.Iic
+-/
 
+#print AntitoneOn.Iic /-
 protected theorem AntitoneOn.Iic (hf : AntitoneOn f s) : AntitoneOn (fun x => Iic (f x)) s :=
   monotone_Iic.comp_antitoneOn hf
 #align antitone_on.Iic AntitoneOn.Iic
+-/
 
+#print Monotone.Ioi /-
 protected theorem Monotone.Ioi (hf : Monotone f) : Antitone fun x => Ioi (f x) :=
   antitone_Ioi.comp_monotone hf
 #align monotone.Ioi Monotone.Ioi
+-/
 
+#print MonotoneOn.Ioi /-
 protected theorem MonotoneOn.Ioi (hf : MonotoneOn f s) : AntitoneOn (fun x => Ioi (f x)) s :=
   antitone_Ioi.comp_monotoneOn hf
 #align monotone_on.Ioi MonotoneOn.Ioi
+-/
 
+#print Antitone.Ioi /-
 protected theorem Antitone.Ioi (hf : Antitone f) : Monotone fun x => Ioi (f x) :=
   antitone_Ioi.comp hf
 #align antitone.Ioi Antitone.Ioi
+-/
 
+#print AntitoneOn.Ioi /-
 protected theorem AntitoneOn.Ioi (hf : AntitoneOn f s) : MonotoneOn (fun x => Ioi (f x)) s :=
   antitone_Ioi.comp_antitoneOn hf
 #align antitone_on.Ioi AntitoneOn.Ioi
+-/
 
+#print Monotone.Iio /-
 protected theorem Monotone.Iio (hf : Monotone f) : Monotone fun x => Iio (f x) :=
   monotone_Iio.comp hf
 #align monotone.Iio Monotone.Iio
+-/
 
+#print MonotoneOn.Iio /-
 protected theorem MonotoneOn.Iio (hf : MonotoneOn f s) : MonotoneOn (fun x => Iio (f x)) s :=
   monotone_Iio.comp_monotoneOn hf
 #align monotone_on.Iio MonotoneOn.Iio
+-/
 
+#print Antitone.Iio /-
 protected theorem Antitone.Iio (hf : Antitone f) : Antitone fun x => Iio (f x) :=
   monotone_Iio.comp_antitone hf
 #align antitone.Iio Antitone.Iio
+-/
 
+#print AntitoneOn.Iio /-
 protected theorem AntitoneOn.Iio (hf : AntitoneOn f s) : AntitoneOn (fun x => Iio (f x)) s :=
   monotone_Iio.comp_antitoneOn hf
 #align antitone_on.Iio AntitoneOn.Iio
+-/
 
+#print Monotone.Icc /-
 protected theorem Monotone.Icc (hf : Monotone f) (hg : Antitone g) :
     Antitone fun x => Icc (f x) (g x) :=
   hf.Ici.inter hg.Iic
 #align monotone.Icc Monotone.Icc
+-/
 
+#print MonotoneOn.Icc /-
 protected theorem MonotoneOn.Icc (hf : MonotoneOn f s) (hg : AntitoneOn g s) :
     AntitoneOn (fun x => Icc (f x) (g x)) s :=
   hf.Ici.inter hg.Iic
 #align monotone_on.Icc MonotoneOn.Icc
+-/
 
+#print Antitone.Icc /-
 protected theorem Antitone.Icc (hf : Antitone f) (hg : Monotone g) :
     Monotone fun x => Icc (f x) (g x) :=
   hf.Ici.inter hg.Iic
 #align antitone.Icc Antitone.Icc
+-/
 
+#print AntitoneOn.Icc /-
 protected theorem AntitoneOn.Icc (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
     MonotoneOn (fun x => Icc (f x) (g x)) s :=
   hf.Ici.inter hg.Iic
 #align antitone_on.Icc AntitoneOn.Icc
+-/
 
+#print Monotone.Ico /-
 protected theorem Monotone.Ico (hf : Monotone f) (hg : Antitone g) :
     Antitone fun x => Ico (f x) (g x) :=
   hf.Ici.inter hg.Iio
 #align monotone.Ico Monotone.Ico
+-/
 
+#print MonotoneOn.Ico /-
 protected theorem MonotoneOn.Ico (hf : MonotoneOn f s) (hg : AntitoneOn g s) :
     AntitoneOn (fun x => Ico (f x) (g x)) s :=
   hf.Ici.inter hg.Iio
 #align monotone_on.Ico MonotoneOn.Ico
+-/
 
+#print Antitone.Ico /-
 protected theorem Antitone.Ico (hf : Antitone f) (hg : Monotone g) :
     Monotone fun x => Ico (f x) (g x) :=
   hf.Ici.inter hg.Iio
 #align antitone.Ico Antitone.Ico
+-/
 
+#print AntitoneOn.Ico /-
 protected theorem AntitoneOn.Ico (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
     MonotoneOn (fun x => Ico (f x) (g x)) s :=
   hf.Ici.inter hg.Iio
 #align antitone_on.Ico AntitoneOn.Ico
+-/
 
+#print Monotone.Ioc /-
 protected theorem Monotone.Ioc (hf : Monotone f) (hg : Antitone g) :
     Antitone fun x => Ioc (f x) (g x) :=
   hf.Ioi.inter hg.Iic
 #align monotone.Ioc Monotone.Ioc
+-/
 
+#print MonotoneOn.Ioc /-
 protected theorem MonotoneOn.Ioc (hf : MonotoneOn f s) (hg : AntitoneOn g s) :
     AntitoneOn (fun x => Ioc (f x) (g x)) s :=
   hf.Ioi.inter hg.Iic
 #align monotone_on.Ioc MonotoneOn.Ioc
+-/
 
+#print Antitone.Ioc /-
 protected theorem Antitone.Ioc (hf : Antitone f) (hg : Monotone g) :
     Monotone fun x => Ioc (f x) (g x) :=
   hf.Ioi.inter hg.Iic
 #align antitone.Ioc Antitone.Ioc
+-/
 
+#print AntitoneOn.Ioc /-
 protected theorem AntitoneOn.Ioc (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
     MonotoneOn (fun x => Ioc (f x) (g x)) s :=
   hf.Ioi.inter hg.Iic
 #align antitone_on.Ioc AntitoneOn.Ioc
+-/
 
+#print Monotone.Ioo /-
 protected theorem Monotone.Ioo (hf : Monotone f) (hg : Antitone g) :
     Antitone fun x => Ioo (f x) (g x) :=
   hf.Ioi.inter hg.Iio
 #align monotone.Ioo Monotone.Ioo
+-/
 
+#print MonotoneOn.Ioo /-
 protected theorem MonotoneOn.Ioo (hf : MonotoneOn f s) (hg : AntitoneOn g s) :
     AntitoneOn (fun x => Ioo (f x) (g x)) s :=
   hf.Ioi.inter hg.Iio
 #align monotone_on.Ioo MonotoneOn.Ioo
+-/
 
+#print Antitone.Ioo /-
 protected theorem Antitone.Ioo (hf : Antitone f) (hg : Monotone g) :
     Monotone fun x => Ioo (f x) (g x) :=
   hf.Ioi.inter hg.Iio
 #align antitone.Ioo Antitone.Ioo
+-/
 
+#print AntitoneOn.Ioo /-
 protected theorem AntitoneOn.Ioo (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
     MonotoneOn (fun x => Ioo (f x) (g x)) s :=
   hf.Ioi.inter hg.Iio
 #align antitone_on.Ioo AntitoneOn.Ioo
+-/
 
 end Ixx
 
@@ -190,6 +262,7 @@ section Union
 
 variable {α β : Type _} [SemilatticeSup α] [LinearOrder β] {f g : α → β} {a b : β}
 
+#print iUnion_Ioo_of_mono_of_isGLB_of_isLUB /-
 theorem iUnion_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
     (ha : IsGLB (range f) a) (hb : IsLUB (range g) b) : (⋃ x, Ioo (f x) (g x)) = Ioo a b :=
   calc
@@ -197,6 +270,7 @@ theorem iUnion_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
       iUnion_inter_of_monotone hf.Ioi hg.Iio
     _ = Ioi a ∩ Iio b := congr_arg₂ (· ∩ ·) ha.iUnion_Ioi_eq hb.iUnion_Iio_eq
 #align Union_Ioo_of_mono_of_is_glb_of_is_lub iUnion_Ioo_of_mono_of_isGLB_of_isLUB
+-/
 
 end Union
 
@@ -236,6 +310,7 @@ theorem StrictMonoOn.Ici_le_id [PredOrder α] [IsPredArchimedean α] [OrderTop 
 
 variable [Preorder β] {ψ : α → β}
 
+#print strictMonoOn_Iic_of_lt_succ /-
 /-- A function `ψ` on a `succ_order` is strictly monotone before some `n` if for all `m` such that
 `m < n`, we have `ψ m < ψ (succ m)`. -/
 theorem strictMonoOn_Iic_of_lt_succ [SuccOrder α] [IsSuccArchimedean α] {n : α}
@@ -264,21 +339,28 @@ theorem strictMonoOn_Iic_of_lt_succ [SuccOrder α] [IsSuccArchimedean α] {n : 
   refine' hψ _ (lt_of_lt_of_le _ hy)
   rwa [Function.iterate_succ', Function.comp_apply, lt_succ_iff_not_is_max]
 #align strict_mono_on_Iic_of_lt_succ strictMonoOn_Iic_of_lt_succ
+-/
 
+#print strictAntiOn_Iic_of_succ_lt /-
 theorem strictAntiOn_Iic_of_succ_lt [SuccOrder α] [IsSuccArchimedean α] {n : α}
     (hψ : ∀ m, m < n → ψ (succ m) < ψ m) : StrictAntiOn ψ (Set.Iic n) := fun i hi j hj hij =>
   @strictMonoOn_Iic_of_lt_succ α βᵒᵈ _ _ ψ _ _ n hψ i hi j hj hij
 #align strict_anti_on_Iic_of_succ_lt strictAntiOn_Iic_of_succ_lt
+-/
 
+#print strictMonoOn_Ici_of_pred_lt /-
 theorem strictMonoOn_Ici_of_pred_lt [PredOrder α] [IsPredArchimedean α] {n : α}
     (hψ : ∀ m, n < m → ψ (pred m) < ψ m) : StrictMonoOn ψ (Set.Ici n) := fun i hi j hj hij =>
   @strictMonoOn_Iic_of_lt_succ αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij
 #align strict_mono_on_Ici_of_pred_lt strictMonoOn_Ici_of_pred_lt
+-/
 
+#print strictAntiOn_Ici_of_lt_pred /-
 theorem strictAntiOn_Ici_of_lt_pred [PredOrder α] [IsPredArchimedean α] {n : α}
     (hψ : ∀ m, n < m → ψ m < ψ (pred m)) : StrictAntiOn ψ (Set.Ici n) := fun i hi j hj hij =>
   @strictAntiOn_Iic_of_succ_lt αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij
 #align strict_anti_on_Ici_of_lt_pred strictAntiOn_Ici_of_lt_pred
+-/
 
 end SuccOrder

4d06b17a

bump to nightly-2023-06-09-07

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

16afdc39

Diff

@@ -196,7 +196,6 @@ theorem iUnion_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
     (⋃ x, Ioo (f x) (g x)) = (⋃ x, Ioi (f x)) ∩ ⋃ x, Iio (g x) :=
       iUnion_inter_of_monotone hf.Ioi hg.Iio
     _ = Ioi a ∩ Iio b := congr_arg₂ (· ∩ ·) ha.iUnion_Ioi_eq hb.iUnion_Iio_eq
-    
 #align Union_Ioo_of_mono_of_is_glb_of_is_lub iUnion_Ioo_of_mono_of_isGLB_of_isLUB
 
 end Union

4d06b17a

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -217,7 +217,7 @@ theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot 
       (fun _ _ hm => hm.trans bot_le) _ _
   rintro k ih hφ m hm
   by_cases hk : IsMax k
-  · rw [succ_eq_iff_is_max.2 hk] at hm
+  · rw [succ_eq_iff_is_max.2 hk] at hm 
     exact ih (hφ.mono <| Iic_subset_Iic.2 (le_succ _)) _ hm
   obtain rfl | h := le_succ_iff_eq_or_le.1 hm
   · specialize ih (StrictMonoOn.mono hφ fun x hx => le_trans hx (le_succ _)) k le_rfl
@@ -249,12 +249,12 @@ theorem strictMonoOn_Iic_of_lt_succ [SuccOrder α] [IsSuccArchimedean α] {n : 
   cases k
   · exact hψ _ (lt_of_lt_of_le hxy hy)
   rw [Set.mem_Iic] at *
-  simp only [Function.iterate_succ', Function.comp_apply] at ih hxy hy⊢
+  simp only [Function.iterate_succ', Function.comp_apply] at ih hxy hy ⊢
   by_cases hmax : IsMax ((succ^[k]) x)
-  · rw [succ_eq_iff_is_max.2 hmax] at hxy⊢
+  · rw [succ_eq_iff_is_max.2 hmax] at hxy ⊢
     exact ih (le_trans (le_succ _) hy) hxy
   by_cases hmax' : IsMax (succ ((succ^[k]) x))
-  · rw [succ_eq_iff_is_max.2 hmax'] at hxy⊢
+  · rw [succ_eq_iff_is_max.2 hmax'] at hxy ⊢
     exact ih (le_trans (le_succ _) hy) hxy
   refine'
     lt_trans

4d06b17a

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -207,6 +207,7 @@ open Order
 
 variable {α β : Type _} [PartialOrder α]
 
+#print StrictMonoOn.Iic_id_le /-
 theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot α] {n : α} {φ : α → α}
     (hφ : StrictMonoOn φ (Set.Iic n)) : ∀ m ≤ n, m ≤ φ m :=
   by
@@ -225,11 +226,14 @@ theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot 
     exact Or.inl rfl
   · exact ih (StrictMonoOn.mono hφ fun x hx => le_trans hx (le_succ _)) _ h
 #align strict_mono_on.Iic_id_le StrictMonoOn.Iic_id_le
+-/
 
+#print StrictMonoOn.Ici_le_id /-
 theorem StrictMonoOn.Ici_le_id [PredOrder α] [IsPredArchimedean α] [OrderTop α] {n : α} {φ : α → α}
     (hφ : StrictMonoOn φ (Set.Ici n)) : ∀ m, n ≤ m → φ m ≤ m :=
   @StrictMonoOn.Iic_id_le αᵒᵈ _ _ _ _ _ _ fun i hi j hj hij => hφ hj hi hij
 #align strict_mono_on.Ici_le_id StrictMonoOn.Ici_le_id
+-/
 
 variable [Preorder β] {ψ : α → β}

4d06b17a

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -28,373 +28,157 @@ section Ixx
 
 variable {α β : Type _} [Preorder α] [Preorder β] {f g : α → β} {s : Set α}
 
-/- warning: antitone_Ici -> antitone_Ici is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], Antitone.{u1, u1} α (Set.{u1} α) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Set.Ici.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], Antitone.{u1, u1} α (Set.{u1} α) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) (Set.Ici.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align antitone_Ici antitone_Iciₓ'. -/
 theorem antitone_Ici : Antitone (Ici : α → Set α) := fun _ _ => Ici_subset_Ici.2
 #align antitone_Ici antitone_Ici
 
-/- warning: monotone_Iic -> monotone_Iic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], Monotone.{u1, u1} α (Set.{u1} α) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Set.Iic.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], Monotone.{u1, u1} α (Set.{u1} α) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) (Set.Iic.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align monotone_Iic monotone_Iicₓ'. -/
 theorem monotone_Iic : Monotone (Iic : α → Set α) := fun _ _ => Iic_subset_Iic.2
 #align monotone_Iic monotone_Iic
 
-/- warning: antitone_Ioi -> antitone_Ioi is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], Antitone.{u1, u1} α (Set.{u1} α) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Set.Ioi.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], Antitone.{u1, u1} α (Set.{u1} α) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) (Set.Ioi.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align antitone_Ioi antitone_Ioiₓ'. -/
 theorem antitone_Ioi : Antitone (Ioi : α → Set α) := fun _ _ => Ioi_subset_Ioi
 #align antitone_Ioi antitone_Ioi
 
-/- warning: monotone_Iio -> monotone_Iio is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], Monotone.{u1, u1} α (Set.{u1} α) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α))))))) (Set.Iio.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α], Monotone.{u1, u1} α (Set.{u1} α) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} α) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))) (Set.Iio.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align monotone_Iio monotone_Iioₓ'. -/
 theorem monotone_Iio : Monotone (Iio : α → Set α) := fun _ _ => Iio_subset_Iio
 #align monotone_Iio monotone_Iio
 
-/- warning: monotone.Ici -> Monotone.Ici is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (Antitone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ici.{u2} β _inst_2 (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (Monotone.{u2, u1} α β _inst_1 _inst_2 f) -> (Antitone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ici.{u1} β _inst_2 (f x)))
-Case conversion may be inaccurate. Consider using '#align monotone.Ici Monotone.Iciₓ'. -/
 protected theorem Monotone.Ici (hf : Monotone f) : Antitone fun x => Ici (f x) :=
   antitone_Ici.comp_monotone hf
 #align monotone.Ici Monotone.Ici
 
-/- warning: monotone_on.Ici -> MonotoneOn.Ici is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ici.{u2} β _inst_2 (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {s : Set.{u2} α}, (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ici.{u1} β _inst_2 (f x)) s)
-Case conversion may be inaccurate. Consider using '#align monotone_on.Ici MonotoneOn.Iciₓ'. -/
 protected theorem MonotoneOn.Ici (hf : MonotoneOn f s) : AntitoneOn (fun x => Ici (f x)) s :=
   antitone_Ici.comp_monotoneOn hf
 #align monotone_on.Ici MonotoneOn.Ici
 
-/- warning: antitone.Ici -> Antitone.Ici is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (Monotone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ici.{u2} β _inst_2 (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (Antitone.{u2, u1} α β _inst_1 _inst_2 f) -> (Monotone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ici.{u1} β _inst_2 (f x)))
-Case conversion may be inaccurate. Consider using '#align antitone.Ici Antitone.Iciₓ'. -/
 protected theorem Antitone.Ici (hf : Antitone f) : Monotone fun x => Ici (f x) :=
   antitone_Ici.comp hf
 #align antitone.Ici Antitone.Ici
 
-/- warning: antitone_on.Ici -> AntitoneOn.Ici is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ici.{u2} β _inst_2 (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {s : Set.{u2} α}, (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ici.{u1} β _inst_2 (f x)) s)
-Case conversion may be inaccurate. Consider using '#align antitone_on.Ici AntitoneOn.Iciₓ'. -/
 protected theorem AntitoneOn.Ici (hf : AntitoneOn f s) : MonotoneOn (fun x => Ici (f x)) s :=
   antitone_Ici.comp_antitoneOn hf
 #align antitone_on.Ici AntitoneOn.Ici
 
-/- warning: monotone.Iic -> Monotone.Iic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (Monotone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Iic.{u2} β _inst_2 (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (Monotone.{u2, u1} α β _inst_1 _inst_2 f) -> (Monotone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Iic.{u1} β _inst_2 (f x)))
-Case conversion may be inaccurate. Consider using '#align monotone.Iic Monotone.Iicₓ'. -/
 protected theorem Monotone.Iic (hf : Monotone f) : Monotone fun x => Iic (f x) :=
   monotone_Iic.comp hf
 #align monotone.Iic Monotone.Iic
 
-/- warning: monotone_on.Iic -> MonotoneOn.Iic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Iic.{u2} β _inst_2 (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {s : Set.{u2} α}, (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Iic.{u1} β _inst_2 (f x)) s)
-Case conversion may be inaccurate. Consider using '#align monotone_on.Iic MonotoneOn.Iicₓ'. -/
 protected theorem MonotoneOn.Iic (hf : MonotoneOn f s) : MonotoneOn (fun x => Iic (f x)) s :=
   monotone_Iic.comp_monotoneOn hf
 #align monotone_on.Iic MonotoneOn.Iic
 
-/- warning: antitone.Iic -> Antitone.Iic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (Antitone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Iic.{u2} β _inst_2 (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (Antitone.{u2, u1} α β _inst_1 _inst_2 f) -> (Antitone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Iic.{u1} β _inst_2 (f x)))
-Case conversion may be inaccurate. Consider using '#align antitone.Iic Antitone.Iicₓ'. -/
 protected theorem Antitone.Iic (hf : Antitone f) : Antitone fun x => Iic (f x) :=
   monotone_Iic.comp_antitone hf
 #align antitone.Iic Antitone.Iic
 
-/- warning: antitone_on.Iic -> AntitoneOn.Iic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Iic.{u2} β _inst_2 (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {s : Set.{u2} α}, (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Iic.{u1} β _inst_2 (f x)) s)
-Case conversion may be inaccurate. Consider using '#align antitone_on.Iic AntitoneOn.Iicₓ'. -/
 protected theorem AntitoneOn.Iic (hf : AntitoneOn f s) : AntitoneOn (fun x => Iic (f x)) s :=
   monotone_Iic.comp_antitoneOn hf
 #align antitone_on.Iic AntitoneOn.Iic
 
-/- warning: monotone.Ioi -> Monotone.Ioi is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (Antitone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioi.{u2} β _inst_2 (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (Monotone.{u2, u1} α β _inst_1 _inst_2 f) -> (Antitone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioi.{u1} β _inst_2 (f x)))
-Case conversion may be inaccurate. Consider using '#align monotone.Ioi Monotone.Ioiₓ'. -/
 protected theorem Monotone.Ioi (hf : Monotone f) : Antitone fun x => Ioi (f x) :=
   antitone_Ioi.comp_monotone hf
 #align monotone.Ioi Monotone.Ioi
 
-/- warning: monotone_on.Ioi -> MonotoneOn.Ioi is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioi.{u2} β _inst_2 (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {s : Set.{u2} α}, (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioi.{u1} β _inst_2 (f x)) s)
-Case conversion may be inaccurate. Consider using '#align monotone_on.Ioi MonotoneOn.Ioiₓ'. -/
 protected theorem MonotoneOn.Ioi (hf : MonotoneOn f s) : AntitoneOn (fun x => Ioi (f x)) s :=
   antitone_Ioi.comp_monotoneOn hf
 #align monotone_on.Ioi MonotoneOn.Ioi
 
-/- warning: antitone.Ioi -> Antitone.Ioi is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (Monotone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioi.{u2} β _inst_2 (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (Antitone.{u2, u1} α β _inst_1 _inst_2 f) -> (Monotone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioi.{u1} β _inst_2 (f x)))
-Case conversion may be inaccurate. Consider using '#align antitone.Ioi Antitone.Ioiₓ'. -/
 protected theorem Antitone.Ioi (hf : Antitone f) : Monotone fun x => Ioi (f x) :=
   antitone_Ioi.comp hf
 #align antitone.Ioi Antitone.Ioi
 
-/- warning: antitone_on.Ioi -> AntitoneOn.Ioi is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioi.{u2} β _inst_2 (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {s : Set.{u2} α}, (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioi.{u1} β _inst_2 (f x)) s)
-Case conversion may be inaccurate. Consider using '#align antitone_on.Ioi AntitoneOn.Ioiₓ'. -/
 protected theorem AntitoneOn.Ioi (hf : AntitoneOn f s) : MonotoneOn (fun x => Ioi (f x)) s :=
   antitone_Ioi.comp_antitoneOn hf
 #align antitone_on.Ioi AntitoneOn.Ioi
 
-/- warning: monotone.Iio -> Monotone.Iio is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (Monotone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Iio.{u2} β _inst_2 (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (Monotone.{u2, u1} α β _inst_1 _inst_2 f) -> (Monotone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Iio.{u1} β _inst_2 (f x)))
-Case conversion may be inaccurate. Consider using '#align monotone.Iio Monotone.Iioₓ'. -/
 protected theorem Monotone.Iio (hf : Monotone f) : Monotone fun x => Iio (f x) :=
   monotone_Iio.comp hf
 #align monotone.Iio Monotone.Iio
 
-/- warning: monotone_on.Iio -> MonotoneOn.Iio is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Iio.{u2} β _inst_2 (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {s : Set.{u2} α}, (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Iio.{u1} β _inst_2 (f x)) s)
-Case conversion may be inaccurate. Consider using '#align monotone_on.Iio MonotoneOn.Iioₓ'. -/
 protected theorem MonotoneOn.Iio (hf : MonotoneOn f s) : MonotoneOn (fun x => Iio (f x)) s :=
   monotone_Iio.comp_monotoneOn hf
 #align monotone_on.Iio MonotoneOn.Iio
 
-/- warning: antitone.Iio -> Antitone.Iio is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (Antitone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Iio.{u2} β _inst_2 (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β}, (Antitone.{u2, u1} α β _inst_1 _inst_2 f) -> (Antitone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Iio.{u1} β _inst_2 (f x)))
-Case conversion may be inaccurate. Consider using '#align antitone.Iio Antitone.Iioₓ'. -/
 protected theorem Antitone.Iio (hf : Antitone f) : Antitone fun x => Iio (f x) :=
   monotone_Iio.comp_antitone hf
 #align antitone.Iio Antitone.Iio
 
-/- warning: antitone_on.Iio -> AntitoneOn.Iio is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Iio.{u2} β _inst_2 (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {s : Set.{u2} α}, (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Iio.{u1} β _inst_2 (f x)) s)
-Case conversion may be inaccurate. Consider using '#align antitone_on.Iio AntitoneOn.Iioₓ'. -/
 protected theorem AntitoneOn.Iio (hf : AntitoneOn f s) : AntitoneOn (fun x => Iio (f x)) s :=
   monotone_Iio.comp_antitoneOn hf
 #align antitone_on.Iio AntitoneOn.Iio
 
-/- warning: monotone.Icc -> Monotone.Icc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (Antitone.{u1, u2} α β _inst_1 _inst_2 g) -> (Antitone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Icc.{u2} β _inst_2 (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β}, (Monotone.{u2, u1} α β _inst_1 _inst_2 f) -> (Antitone.{u2, u1} α β _inst_1 _inst_2 g) -> (Antitone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Icc.{u1} β _inst_2 (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align monotone.Icc Monotone.Iccₓ'. -/
 protected theorem Monotone.Icc (hf : Monotone f) (hg : Antitone g) :
     Antitone fun x => Icc (f x) (g x) :=
   hf.Ici.inter hg.Iic
 #align monotone.Icc Monotone.Icc
 
-/- warning: monotone_on.Icc -> MonotoneOn.Icc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 g s) -> (AntitoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Icc.{u2} β _inst_2 (f x) (g x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {s : Set.{u2} α}, (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 g s) -> (AntitoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Icc.{u1} β _inst_2 (f x) (g x)) s)
-Case conversion may be inaccurate. Consider using '#align monotone_on.Icc MonotoneOn.Iccₓ'. -/
 protected theorem MonotoneOn.Icc (hf : MonotoneOn f s) (hg : AntitoneOn g s) :
     AntitoneOn (fun x => Icc (f x) (g x)) s :=
   hf.Ici.inter hg.Iic
 #align monotone_on.Icc MonotoneOn.Icc
 
-/- warning: antitone.Icc -> Antitone.Icc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (Monotone.{u1, u2} α β _inst_1 _inst_2 g) -> (Monotone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Icc.{u2} β _inst_2 (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β}, (Antitone.{u2, u1} α β _inst_1 _inst_2 f) -> (Monotone.{u2, u1} α β _inst_1 _inst_2 g) -> (Monotone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Icc.{u1} β _inst_2 (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align antitone.Icc Antitone.Iccₓ'. -/
 protected theorem Antitone.Icc (hf : Antitone f) (hg : Monotone g) :
     Monotone fun x => Icc (f x) (g x) :=
   hf.Ici.inter hg.Iic
 #align antitone.Icc Antitone.Icc
 
-/- warning: antitone_on.Icc -> AntitoneOn.Icc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 g s) -> (MonotoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Icc.{u2} β _inst_2 (f x) (g x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {s : Set.{u2} α}, (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 g s) -> (MonotoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Icc.{u1} β _inst_2 (f x) (g x)) s)
-Case conversion may be inaccurate. Consider using '#align antitone_on.Icc AntitoneOn.Iccₓ'. -/
 protected theorem AntitoneOn.Icc (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
     MonotoneOn (fun x => Icc (f x) (g x)) s :=
   hf.Ici.inter hg.Iic
 #align antitone_on.Icc AntitoneOn.Icc
 
-/- warning: monotone.Ico -> Monotone.Ico is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (Antitone.{u1, u2} α β _inst_1 _inst_2 g) -> (Antitone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ico.{u2} β _inst_2 (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β}, (Monotone.{u2, u1} α β _inst_1 _inst_2 f) -> (Antitone.{u2, u1} α β _inst_1 _inst_2 g) -> (Antitone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ico.{u1} β _inst_2 (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align monotone.Ico Monotone.Icoₓ'. -/
 protected theorem Monotone.Ico (hf : Monotone f) (hg : Antitone g) :
     Antitone fun x => Ico (f x) (g x) :=
   hf.Ici.inter hg.Iio
 #align monotone.Ico Monotone.Ico
 
-/- warning: monotone_on.Ico -> MonotoneOn.Ico is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 g s) -> (AntitoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ico.{u2} β _inst_2 (f x) (g x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {s : Set.{u2} α}, (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 g s) -> (AntitoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ico.{u1} β _inst_2 (f x) (g x)) s)
-Case conversion may be inaccurate. Consider using '#align monotone_on.Ico MonotoneOn.Icoₓ'. -/
 protected theorem MonotoneOn.Ico (hf : MonotoneOn f s) (hg : AntitoneOn g s) :
     AntitoneOn (fun x => Ico (f x) (g x)) s :=
   hf.Ici.inter hg.Iio
 #align monotone_on.Ico MonotoneOn.Ico
 
-/- warning: antitone.Ico -> Antitone.Ico is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (Monotone.{u1, u2} α β _inst_1 _inst_2 g) -> (Monotone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ico.{u2} β _inst_2 (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β}, (Antitone.{u2, u1} α β _inst_1 _inst_2 f) -> (Monotone.{u2, u1} α β _inst_1 _inst_2 g) -> (Monotone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ico.{u1} β _inst_2 (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align antitone.Ico Antitone.Icoₓ'. -/
 protected theorem Antitone.Ico (hf : Antitone f) (hg : Monotone g) :
     Monotone fun x => Ico (f x) (g x) :=
   hf.Ici.inter hg.Iio
 #align antitone.Ico Antitone.Ico
 
-/- warning: antitone_on.Ico -> AntitoneOn.Ico is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 g s) -> (MonotoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ico.{u2} β _inst_2 (f x) (g x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {s : Set.{u2} α}, (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 g s) -> (MonotoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ico.{u1} β _inst_2 (f x) (g x)) s)
-Case conversion may be inaccurate. Consider using '#align antitone_on.Ico AntitoneOn.Icoₓ'. -/
 protected theorem AntitoneOn.Ico (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
     MonotoneOn (fun x => Ico (f x) (g x)) s :=
   hf.Ici.inter hg.Iio
 #align antitone_on.Ico AntitoneOn.Ico
 
-/- warning: monotone.Ioc -> Monotone.Ioc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (Antitone.{u1, u2} α β _inst_1 _inst_2 g) -> (Antitone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioc.{u2} β _inst_2 (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β}, (Monotone.{u2, u1} α β _inst_1 _inst_2 f) -> (Antitone.{u2, u1} α β _inst_1 _inst_2 g) -> (Antitone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioc.{u1} β _inst_2 (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align monotone.Ioc Monotone.Iocₓ'. -/
 protected theorem Monotone.Ioc (hf : Monotone f) (hg : Antitone g) :
     Antitone fun x => Ioc (f x) (g x) :=
   hf.Ioi.inter hg.Iic
 #align monotone.Ioc Monotone.Ioc
 
-/- warning: monotone_on.Ioc -> MonotoneOn.Ioc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 g s) -> (AntitoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioc.{u2} β _inst_2 (f x) (g x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {s : Set.{u2} α}, (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 g s) -> (AntitoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioc.{u1} β _inst_2 (f x) (g x)) s)
-Case conversion may be inaccurate. Consider using '#align monotone_on.Ioc MonotoneOn.Iocₓ'. -/
 protected theorem MonotoneOn.Ioc (hf : MonotoneOn f s) (hg : AntitoneOn g s) :
     AntitoneOn (fun x => Ioc (f x) (g x)) s :=
   hf.Ioi.inter hg.Iic
 #align monotone_on.Ioc MonotoneOn.Ioc
 
-/- warning: antitone.Ioc -> Antitone.Ioc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (Monotone.{u1, u2} α β _inst_1 _inst_2 g) -> (Monotone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioc.{u2} β _inst_2 (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β}, (Antitone.{u2, u1} α β _inst_1 _inst_2 f) -> (Monotone.{u2, u1} α β _inst_1 _inst_2 g) -> (Monotone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioc.{u1} β _inst_2 (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align antitone.Ioc Antitone.Iocₓ'. -/
 protected theorem Antitone.Ioc (hf : Antitone f) (hg : Monotone g) :
     Monotone fun x => Ioc (f x) (g x) :=
   hf.Ioi.inter hg.Iic
 #align antitone.Ioc Antitone.Ioc
 
-/- warning: antitone_on.Ioc -> AntitoneOn.Ioc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 g s) -> (MonotoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioc.{u2} β _inst_2 (f x) (g x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {s : Set.{u2} α}, (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 g s) -> (MonotoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioc.{u1} β _inst_2 (f x) (g x)) s)
-Case conversion may be inaccurate. Consider using '#align antitone_on.Ioc AntitoneOn.Iocₓ'. -/
 protected theorem AntitoneOn.Ioc (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
     MonotoneOn (fun x => Ioc (f x) (g x)) s :=
   hf.Ioi.inter hg.Iic
 #align antitone_on.Ioc AntitoneOn.Ioc
 
-/- warning: monotone.Ioo -> Monotone.Ioo is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (Monotone.{u1, u2} α β _inst_1 _inst_2 f) -> (Antitone.{u1, u2} α β _inst_1 _inst_2 g) -> (Antitone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioo.{u2} β _inst_2 (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β}, (Monotone.{u2, u1} α β _inst_1 _inst_2 f) -> (Antitone.{u2, u1} α β _inst_1 _inst_2 g) -> (Antitone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioo.{u1} β _inst_2 (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align monotone.Ioo Monotone.Iooₓ'. -/
 protected theorem Monotone.Ioo (hf : Monotone f) (hg : Antitone g) :
     Antitone fun x => Ioo (f x) (g x) :=
   hf.Ioi.inter hg.Iio
 #align monotone.Ioo Monotone.Ioo
 
-/- warning: monotone_on.Ioo -> MonotoneOn.Ioo is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {s : Set.{u1} α}, (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 g s) -> (AntitoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioo.{u2} β _inst_2 (f x) (g x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {s : Set.{u2} α}, (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 g s) -> (AntitoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioo.{u1} β _inst_2 (f x) (g x)) s)
-Case conversion may be inaccurate. Consider using '#align monotone_on.Ioo MonotoneOn.Iooₓ'. -/
 protected theorem MonotoneOn.Ioo (hf : MonotoneOn f s) (hg : AntitoneOn g s) :
     AntitoneOn (fun x => Ioo (f x) (g x)) s :=
   hf.Ioi.inter hg.Iio
 #align monotone_on.Ioo MonotoneOn.Ioo
 
-/- warning: antitone.Ioo -> Antitone.Ioo is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β}, (Antitone.{u1, u2} α β _inst_1 _inst_2 f) -> (Monotone.{u1, u2} α β _inst_1 _inst_2 g) -> (Monotone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioo.{u2} β _inst_2 (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β}, (Antitone.{u2, u1} α β _inst_1 _inst_2 f) -> (Monotone.{u2, u1} α β _inst_1 _inst_2 g) -> (Monotone.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioo.{u1} β _inst_2 (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align antitone.Ioo Antitone.Iooₓ'. -/
 protected theorem Antitone.Ioo (hf : Antitone f) (hg : Monotone g) :
     Monotone fun x => Ioo (f x) (g x) :=
   hf.Ioi.inter hg.Iio
 #align antitone.Ioo Antitone.Ioo
 
-/- warning: antitone_on.Ioo -> AntitoneOn.Ioo is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {f : α -> β} {g : α -> β} {s : Set.{u1} α}, (AntitoneOn.{u1, u2} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u1, u2} α β _inst_1 _inst_2 g s) -> (MonotoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (CompleteSemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Set.{u2} β) (Order.Coframe.toCompleteLattice.{u2} (Set.{u2} β) (CompleteDistribLattice.toCoframe.{u2} (Set.{u2} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u2} (Set.{u2} β) (Set.completeBooleanAlgebra.{u2} β))))))) (fun (x : α) => Set.Ioo.{u2} β _inst_2 (f x) (g x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {f : α -> β} {g : α -> β} {s : Set.{u2} α}, (AntitoneOn.{u2, u1} α β _inst_1 _inst_2 f s) -> (MonotoneOn.{u2, u1} α β _inst_1 _inst_2 g s) -> (MonotoneOn.{u2, u1} α (Set.{u1} β) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} β) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} β) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} β) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} β) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} β) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} β) (Set.instCompleteBooleanAlgebraSet.{u1} β))))))) (fun (x : α) => Set.Ioo.{u1} β _inst_2 (f x) (g x)) s)
-Case conversion may be inaccurate. Consider using '#align antitone_on.Ioo AntitoneOn.Iooₓ'. -/
 protected theorem AntitoneOn.Ioo (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
     MonotoneOn (fun x => Ioo (f x) (g x)) s :=
   hf.Ioi.inter hg.Iio
@@ -406,12 +190,6 @@ section Union
 
 variable {α β : Type _} [SemilatticeSup α] [LinearOrder β] {f g : α → β} {a b : β}
 
-/- warning: Union_Ioo_of_mono_of_is_glb_of_is_lub -> iUnion_Ioo_of_mono_of_isGLB_of_isLUB is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : β} {b : β}, (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) f) -> (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) g) -> (IsGLB.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) (Set.range.{u2, succ u1} β α f) a) -> (IsLUB.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) (Set.range.{u2, succ u1} β α g) b) -> (Eq.{succ u2} (Set.{u2} β) (Set.iUnion.{u2, succ u1} β α (fun (x : α) => Set.Ioo.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) (f x) (g x))) (Set.Ioo.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) a b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : SemilatticeSup.{u2} α] [_inst_2 : LinearOrder.{u1} β] {f : α -> β} {g : α -> β} {a : β} {b : β}, (Antitone.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_1)) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) f) -> (Monotone.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_1)) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) g) -> (IsGLB.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) (Set.range.{u1, succ u2} β α f) a) -> (IsLUB.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) (Set.range.{u1, succ u2} β α g) b) -> (Eq.{succ u1} (Set.{u1} β) (Set.iUnion.{u1, succ u2} β α (fun (x : α) => Set.Ioo.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) (f x) (g x))) (Set.Ioo.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) a b))
-Case conversion may be inaccurate. Consider using '#align Union_Ioo_of_mono_of_is_glb_of_is_lub iUnion_Ioo_of_mono_of_isGLB_of_isLUBₓ'. -/
 theorem iUnion_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
     (ha : IsGLB (range f) a) (hb : IsLUB (range g) b) : (⋃ x, Ioo (f x) (g x)) = Ioo a b :=
   calc
@@ -429,12 +207,6 @@ open Order
 
 variable {α β : Type _} [PartialOrder α]
 
-/- warning: strict_mono_on.Iic_id_le -> StrictMonoOn.Iic_id_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] {n : α} {φ : α -> α}, (StrictMonoOn.{u1, u1} α α (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_1) φ (Set.Iic.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n)) -> (forall (m : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m (φ m)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] {n : α} {φ : α -> α}, (StrictMonoOn.{u1, u1} α α (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_1) φ (Set.Iic.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n)) -> (forall (m : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m (φ m)))
-Case conversion may be inaccurate. Consider using '#align strict_mono_on.Iic_id_le StrictMonoOn.Iic_id_leₓ'. -/
 theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot α] {n : α} {φ : α → α}
     (hφ : StrictMonoOn φ (Set.Iic n)) : ∀ m ≤ n, m ≤ φ m :=
   by
@@ -454,12 +226,6 @@ theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot 
   · exact ih (StrictMonoOn.mono hφ fun x hx => le_trans hx (le_succ _)) _ h
 #align strict_mono_on.Iic_id_le StrictMonoOn.Iic_id_le
 
-/- warning: strict_mono_on.Ici_le_id -> StrictMonoOn.Ici_le_id is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] {n : α} {φ : α -> α}, (StrictMonoOn.{u1, u1} α α (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_1) φ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n)) -> (forall (m : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (φ m) m))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] {n : α} {φ : α -> α}, (StrictMonoOn.{u1, u1} α α (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_1) φ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n)) -> (forall (m : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (φ m) m))
-Case conversion may be inaccurate. Consider using '#align strict_mono_on.Ici_le_id StrictMonoOn.Ici_le_idₓ'. -/
 theorem StrictMonoOn.Ici_le_id [PredOrder α] [IsPredArchimedean α] [OrderTop α] {n : α} {φ : α → α}
     (hφ : StrictMonoOn φ (Set.Ici n)) : ∀ m, n ≤ m → φ m ≤ m :=
   @StrictMonoOn.Iic_id_le αᵒᵈ _ _ _ _ _ _ fun i hi j hj hij => hφ hj hi hij
@@ -467,12 +233,6 @@ theorem StrictMonoOn.Ici_le_id [PredOrder α] [IsPredArchimedean α] [OrderTop 
 
 variable [Preorder β] {ψ : α → β}
 
-/- warning: strict_mono_on_Iic_of_lt_succ -> strictMonoOn_Iic_of_lt_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m n) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (ψ m) (ψ (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)))) -> (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Iic.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : SuccOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsSuccArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) m n) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ m) (ψ (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)))) -> (StrictMonoOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Iic.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
-Case conversion may be inaccurate. Consider using '#align strict_mono_on_Iic_of_lt_succ strictMonoOn_Iic_of_lt_succₓ'. -/
 /-- A function `ψ` on a `succ_order` is strictly monotone before some `n` if for all `m` such that
 `m < n`, we have `ψ m < ψ (succ m)`. -/
 theorem strictMonoOn_Iic_of_lt_succ [SuccOrder α] [IsSuccArchimedean α] {n : α}
@@ -502,34 +262,16 @@ theorem strictMonoOn_Iic_of_lt_succ [SuccOrder α] [IsSuccArchimedean α] {n : 
   rwa [Function.iterate_succ', Function.comp_apply, lt_succ_iff_not_is_max]
 #align strict_mono_on_Iic_of_lt_succ strictMonoOn_Iic_of_lt_succ
 
-/- warning: strict_anti_on_Iic_of_succ_lt -> strictAntiOn_Iic_of_succ_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m n) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (ψ (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Iic.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : SuccOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsSuccArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) m n) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictAntiOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Iic.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
-Case conversion may be inaccurate. Consider using '#align strict_anti_on_Iic_of_succ_lt strictAntiOn_Iic_of_succ_ltₓ'. -/
 theorem strictAntiOn_Iic_of_succ_lt [SuccOrder α] [IsSuccArchimedean α] {n : α}
     (hψ : ∀ m, m < n → ψ (succ m) < ψ m) : StrictAntiOn ψ (Set.Iic n) := fun i hi j hj hij =>
   @strictMonoOn_Iic_of_lt_succ α βᵒᵈ _ _ ψ _ _ n hψ i hi j hj hij
 #align strict_anti_on_Iic_of_succ_lt strictAntiOn_Iic_of_succ_lt
 
-/- warning: strict_mono_on_Ici_of_pred_lt -> strictMonoOn_Ici_of_pred_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (ψ (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsPredArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) n m) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictMonoOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Ici.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
-Case conversion may be inaccurate. Consider using '#align strict_mono_on_Ici_of_pred_lt strictMonoOn_Ici_of_pred_ltₓ'. -/
 theorem strictMonoOn_Ici_of_pred_lt [PredOrder α] [IsPredArchimedean α] {n : α}
     (hψ : ∀ m, n < m → ψ (pred m) < ψ m) : StrictMonoOn ψ (Set.Ici n) := fun i hi j hj hij =>
   @strictMonoOn_Iic_of_lt_succ αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij
 #align strict_mono_on_Ici_of_pred_lt strictMonoOn_Ici_of_pred_lt
 
-/- warning: strict_anti_on_Ici_of_lt_pred -> strictAntiOn_Ici_of_lt_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (ψ m) (ψ (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)))) -> (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsPredArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) n m) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ m) (ψ (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)))) -> (StrictAntiOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Ici.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
-Case conversion may be inaccurate. Consider using '#align strict_anti_on_Ici_of_lt_pred strictAntiOn_Ici_of_lt_predₓ'. -/
 theorem strictAntiOn_Ici_of_lt_pred [PredOrder α] [IsPredArchimedean α] {n : α}
     (hψ : ∀ m, n < m → ψ m < ψ (pred m)) : StrictAntiOn ψ (Set.Ici n) := fun i hi j hj hij =>
   @strictAntiOn_Iic_of_succ_lt αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij

4d06b17a

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -429,7 +429,12 @@ open Order
 
 variable {α β : Type _} [PartialOrder α]
 
-#print StrictMonoOn.Iic_id_le /-
+/- warning: strict_mono_on.Iic_id_le -> StrictMonoOn.Iic_id_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] {n : α} {φ : α -> α}, (StrictMonoOn.{u1, u1} α α (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_1) φ (Set.Iic.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n)) -> (forall (m : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m n) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m (φ m)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] {n : α} {φ : α -> α}, (StrictMonoOn.{u1, u1} α α (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_1) φ (Set.Iic.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n)) -> (forall (m : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m n) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m (φ m)))
+Case conversion may be inaccurate. Consider using '#align strict_mono_on.Iic_id_le StrictMonoOn.Iic_id_leₓ'. -/
 theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot α] {n : α} {φ : α → α}
     (hφ : StrictMonoOn φ (Set.Iic n)) : ∀ m ≤ n, m ≤ φ m :=
   by
@@ -448,20 +453,23 @@ theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot 
     exact Or.inl rfl
   · exact ih (StrictMonoOn.mono hφ fun x hx => le_trans hx (le_succ _)) _ h
 #align strict_mono_on.Iic_id_le StrictMonoOn.Iic_id_le
--/
 
-#print StrictMonoOn.Ici_le_id /-
+/- warning: strict_mono_on.Ici_le_id -> StrictMonoOn.Ici_le_id is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] {n : α} {φ : α -> α}, (StrictMonoOn.{u1, u1} α α (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_1) φ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n)) -> (forall (m : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (φ m) m))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] {n : α} {φ : α -> α}, (StrictMonoOn.{u1, u1} α α (PartialOrder.toPreorder.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_1) φ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n)) -> (forall (m : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (φ m) m))
+Case conversion may be inaccurate. Consider using '#align strict_mono_on.Ici_le_id StrictMonoOn.Ici_le_idₓ'. -/
 theorem StrictMonoOn.Ici_le_id [PredOrder α] [IsPredArchimedean α] [OrderTop α] {n : α} {φ : α → α}
     (hφ : StrictMonoOn φ (Set.Ici n)) : ∀ m, n ≤ m → φ m ≤ m :=
   @StrictMonoOn.Iic_id_le αᵒᵈ _ _ _ _ _ _ fun i hi j hj hij => hφ hj hi hij
 #align strict_mono_on.Ici_le_id StrictMonoOn.Ici_le_id
--/
 
 variable [Preorder β] {ψ : α → β}
 
 /- warning: strict_mono_on_Iic_of_lt_succ -> strictMonoOn_Iic_of_lt_succ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m n) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (ψ m) (ψ (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)))) -> (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Iic.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m n) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (ψ m) (ψ (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)))) -> (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Iic.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : SuccOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsSuccArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) m n) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ m) (ψ (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)))) -> (StrictMonoOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Iic.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
 Case conversion may be inaccurate. Consider using '#align strict_mono_on_Iic_of_lt_succ strictMonoOn_Iic_of_lt_succₓ'. -/
@@ -496,7 +504,7 @@ theorem strictMonoOn_Iic_of_lt_succ [SuccOrder α] [IsSuccArchimedean α] {n : 
 
 /- warning: strict_anti_on_Iic_of_succ_lt -> strictAntiOn_Iic_of_succ_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m n) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (ψ (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Iic.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) m n) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (ψ (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Iic.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : SuccOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsSuccArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) m n) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictAntiOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Iic.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
 Case conversion may be inaccurate. Consider using '#align strict_anti_on_Iic_of_succ_lt strictAntiOn_Iic_of_succ_ltₓ'. -/
@@ -507,7 +515,7 @@ theorem strictAntiOn_Iic_of_succ_lt [SuccOrder α] [IsSuccArchimedean α] {n : 
 
 /- warning: strict_mono_on_Ici_of_pred_lt -> strictMonoOn_Ici_of_pred_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (ψ (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (ψ (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsPredArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) n m) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictMonoOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Ici.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
 Case conversion may be inaccurate. Consider using '#align strict_mono_on_Ici_of_pred_lt strictMonoOn_Ici_of_pred_ltₓ'. -/
@@ -518,7 +526,7 @@ theorem strictMonoOn_Ici_of_pred_lt [PredOrder α] [IsPredArchimedean α] {n : 
 
 /- warning: strict_anti_on_Ici_of_lt_pred -> strictAntiOn_Ici_of_lt_pred is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (ψ m) (ψ (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)))) -> (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LT.lt.{u2} β (Preorder.toHasLt.{u2} β _inst_2) (ψ m) (ψ (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)))) -> (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsPredArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) n m) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ m) (ψ (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)))) -> (StrictAntiOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Ici.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
 Case conversion may be inaccurate. Consider using '#align strict_anti_on_Ici_of_lt_pred strictAntiOn_Ici_of_lt_predₓ'. -/

4d06b17a

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -406,20 +406,20 @@ section Union
 
 variable {α β : Type _} [SemilatticeSup α] [LinearOrder β] {f g : α → β} {a b : β}
 
-/- warning: Union_Ioo_of_mono_of_is_glb_of_is_lub -> unionᵢ_Ioo_of_mono_of_isGLB_of_isLUB is a dubious translation:
+/- warning: Union_Ioo_of_mono_of_is_glb_of_is_lub -> iUnion_Ioo_of_mono_of_isGLB_of_isLUB is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : β} {b : β}, (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) f) -> (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) g) -> (IsGLB.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) (Set.range.{u2, succ u1} β α f) a) -> (IsLUB.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) (Set.range.{u2, succ u1} β α g) b) -> (Eq.{succ u2} (Set.{u2} β) (Set.unionᵢ.{u2, succ u1} β α (fun (x : α) => Set.Ioo.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) (f x) (g x))) (Set.Ioo.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) a b))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : SemilatticeSup.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β} {g : α -> β} {a : β} {b : β}, (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) f) -> (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeSup.toPartialOrder.{u1} α _inst_1)) (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) g) -> (IsGLB.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) (Set.range.{u2, succ u1} β α f) a) -> (IsLUB.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) (Set.range.{u2, succ u1} β α g) b) -> (Eq.{succ u2} (Set.{u2} β) (Set.iUnion.{u2, succ u1} β α (fun (x : α) => Set.Ioo.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) (f x) (g x))) (Set.Ioo.{u2} β (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) a b))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : SemilatticeSup.{u2} α] [_inst_2 : LinearOrder.{u1} β] {f : α -> β} {g : α -> β} {a : β} {b : β}, (Antitone.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_1)) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) f) -> (Monotone.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_1)) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) g) -> (IsGLB.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) (Set.range.{u1, succ u2} β α f) a) -> (IsLUB.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) (Set.range.{u1, succ u2} β α g) b) -> (Eq.{succ u1} (Set.{u1} β) (Set.unionᵢ.{u1, succ u2} β α (fun (x : α) => Set.Ioo.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) (f x) (g x))) (Set.Ioo.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) a b))
-Case conversion may be inaccurate. Consider using '#align Union_Ioo_of_mono_of_is_glb_of_is_lub unionᵢ_Ioo_of_mono_of_isGLB_of_isLUBₓ'. -/
-theorem unionᵢ_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : SemilatticeSup.{u2} α] [_inst_2 : LinearOrder.{u1} β] {f : α -> β} {g : α -> β} {a : β} {b : β}, (Antitone.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_1)) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) f) -> (Monotone.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeSup.toPartialOrder.{u2} α _inst_1)) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) g) -> (IsGLB.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) (Set.range.{u1, succ u2} β α f) a) -> (IsLUB.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) (Set.range.{u1, succ u2} β α g) b) -> (Eq.{succ u1} (Set.{u1} β) (Set.iUnion.{u1, succ u2} β α (fun (x : α) => Set.Ioo.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) (f x) (g x))) (Set.Ioo.{u1} β (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) a b))
+Case conversion may be inaccurate. Consider using '#align Union_Ioo_of_mono_of_is_glb_of_is_lub iUnion_Ioo_of_mono_of_isGLB_of_isLUBₓ'. -/
+theorem iUnion_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
     (ha : IsGLB (range f) a) (hb : IsLUB (range g) b) : (⋃ x, Ioo (f x) (g x)) = Ioo a b :=
   calc
     (⋃ x, Ioo (f x) (g x)) = (⋃ x, Ioi (f x)) ∩ ⋃ x, Iio (g x) :=
-      unionᵢ_inter_of_monotone hf.Ioi hg.Iio
-    _ = Ioi a ∩ Iio b := congr_arg₂ (· ∩ ·) ha.unionᵢ_Ioi_eq hb.unionᵢ_Iio_eq
+      iUnion_inter_of_monotone hf.Ioi hg.Iio
+    _ = Ioi a ∩ Iio b := congr_arg₂ (· ∩ ·) ha.iUnion_Ioi_eq hb.iUnion_Iio_eq
     
-#align Union_Ioo_of_mono_of_is_glb_of_is_lub unionᵢ_Ioo_of_mono_of_isGLB_of_isLUB
+#align Union_Ioo_of_mono_of_is_glb_of_is_lub iUnion_Ioo_of_mono_of_isGLB_of_isLUB
 
 end Union

4d06b17a

bump to nightly-2023-05-06-10

mathlib commit https://github.com/leanprover-community/mathlib/commit/3905fa80e62c0898131285baab35559fbc4e5cda

c6fb1d2b

Diff

@@ -450,10 +450,12 @@ theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot 
 #align strict_mono_on.Iic_id_le StrictMonoOn.Iic_id_le
 -/
 
+#print StrictMonoOn.Ici_le_id /-
 theorem StrictMonoOn.Ici_le_id [PredOrder α] [IsPredArchimedean α] [OrderTop α] {n : α} {φ : α → α}
     (hφ : StrictMonoOn φ (Set.Ici n)) : ∀ m, n ≤ m → φ m ≤ m :=
   @StrictMonoOn.Iic_id_le αᵒᵈ _ _ _ _ _ _ fun i hi j hj hij => hφ hj hi hij
 #align strict_mono_on.Ici_le_id StrictMonoOn.Ici_le_id
+-/
 
 variable [Preorder β] {ψ : α → β}
 
@@ -503,11 +505,23 @@ theorem strictAntiOn_Iic_of_succ_lt [SuccOrder α] [IsSuccArchimedean α] {n : 
   @strictMonoOn_Iic_of_lt_succ α βᵒᵈ _ _ ψ _ _ n hψ i hi j hj hij
 #align strict_anti_on_Iic_of_succ_lt strictAntiOn_Iic_of_succ_lt
 
+/- warning: strict_mono_on_Ici_of_pred_lt -> strictMonoOn_Ici_of_pred_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (ψ (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsPredArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) n m) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictMonoOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Ici.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
+Case conversion may be inaccurate. Consider using '#align strict_mono_on_Ici_of_pred_lt strictMonoOn_Ici_of_pred_ltₓ'. -/
 theorem strictMonoOn_Ici_of_pred_lt [PredOrder α] [IsPredArchimedean α] {n : α}
     (hψ : ∀ m, n < m → ψ (pred m) < ψ m) : StrictMonoOn ψ (Set.Ici n) := fun i hi j hj hij =>
   @strictMonoOn_Iic_of_lt_succ αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij
 #align strict_mono_on_Ici_of_pred_lt strictMonoOn_Ici_of_pred_lt
 
+/- warning: strict_anti_on_Ici_of_lt_pred -> strictAntiOn_Ici_of_lt_pred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (ψ m) (ψ (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)))) -> (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsPredArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) n m) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ m) (ψ (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)))) -> (StrictAntiOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Ici.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
+Case conversion may be inaccurate. Consider using '#align strict_anti_on_Ici_of_lt_pred strictAntiOn_Ici_of_lt_predₓ'. -/
 theorem strictAntiOn_Ici_of_lt_pred [PredOrder α] [IsPredArchimedean α] {n : α}
     (hψ : ∀ m, n < m → ψ m < ψ (pred m)) : StrictAntiOn ψ (Set.Ici n) := fun i hi j hj hij =>
   @strictAntiOn_Iic_of_succ_lt αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij

4d06b17a

bump to nightly-2023-05-04-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/92c69b77c5a7dc0f7eeddb552508633305157caa

047afb6f

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 
 ! This file was ported from Lean 3 source module data.set.intervals.monotone
-! leanprover-community/mathlib commit baba818b9acea366489e8ba32d2cc0fcaf50a1f7
+! leanprover-community/mathlib commit 4d06b17aea8cf2e220f0b0aa46cd0231593c5c97
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -450,12 +450,10 @@ theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot 
 #align strict_mono_on.Iic_id_le StrictMonoOn.Iic_id_le
 -/
 
-#print StrictMonoOn.Iic_le_id /-
-theorem StrictMonoOn.Iic_le_id [PredOrder α] [IsPredArchimedean α] [OrderTop α] {n : α} {φ : α → α}
+theorem StrictMonoOn.Ici_le_id [PredOrder α] [IsPredArchimedean α] [OrderTop α] {n : α} {φ : α → α}
     (hφ : StrictMonoOn φ (Set.Ici n)) : ∀ m, n ≤ m → φ m ≤ m :=
   @StrictMonoOn.Iic_id_le αᵒᵈ _ _ _ _ _ _ fun i hi j hj hij => hφ hj hi hij
-#align strict_mono_on.Iic_le_id StrictMonoOn.Iic_le_id
--/
+#align strict_mono_on.Ici_le_id StrictMonoOn.Ici_le_id
 
 variable [Preorder β] {ψ : α → β}
 
@@ -505,27 +503,15 @@ theorem strictAntiOn_Iic_of_succ_lt [SuccOrder α] [IsSuccArchimedean α] {n : 
   @strictMonoOn_Iic_of_lt_succ α βᵒᵈ _ _ ψ _ _ n hψ i hi j hj hij
 #align strict_anti_on_Iic_of_succ_lt strictAntiOn_Iic_of_succ_lt
 
-/- warning: strict_mono_on_Iic_of_pred_lt -> strictMonoOn_Iic_of_pred_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (ψ (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictMonoOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsPredArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) n m) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)) (ψ m))) -> (StrictMonoOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Ici.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
-Case conversion may be inaccurate. Consider using '#align strict_mono_on_Iic_of_pred_lt strictMonoOn_Iic_of_pred_ltₓ'. -/
-theorem strictMonoOn_Iic_of_pred_lt [PredOrder α] [IsPredArchimedean α] {n : α}
+theorem strictMonoOn_Ici_of_pred_lt [PredOrder α] [IsPredArchimedean α] {n : α}
     (hψ : ∀ m, n < m → ψ (pred m) < ψ m) : StrictMonoOn ψ (Set.Ici n) := fun i hi j hj hij =>
   @strictMonoOn_Iic_of_lt_succ αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij
-#align strict_mono_on_Iic_of_pred_lt strictMonoOn_Iic_of_pred_lt
+#align strict_mono_on_Ici_of_pred_lt strictMonoOn_Ici_of_pred_lt
 
-/- warning: strict_anti_on_Iic_of_lt_pred -> strictAntiOn_Iic_of_lt_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {ψ : α -> β} [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) n m) -> (LT.lt.{u2} β (Preorder.toLT.{u2} β _inst_2) (ψ m) (ψ (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 m)))) -> (StrictAntiOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 ψ (Set.Ici.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) n))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {ψ : α -> β} [_inst_3 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] [_inst_4 : IsPredArchimedean.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3] {n : α}, (forall (m : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) n m) -> (LT.lt.{u1} β (Preorder.toLT.{u1} β _inst_2) (ψ m) (ψ (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 m)))) -> (StrictAntiOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 ψ (Set.Ici.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) n))
-Case conversion may be inaccurate. Consider using '#align strict_anti_on_Iic_of_lt_pred strictAntiOn_Iic_of_lt_predₓ'. -/
-theorem strictAntiOn_Iic_of_lt_pred [PredOrder α] [IsPredArchimedean α] {n : α}
+theorem strictAntiOn_Ici_of_lt_pred [PredOrder α] [IsPredArchimedean α] {n : α}
     (hψ : ∀ m, n < m → ψ m < ψ (pred m)) : StrictAntiOn ψ (Set.Ici n) := fun i hi j hj hij =>
   @strictAntiOn_Iic_of_succ_lt αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij
-#align strict_anti_on_Iic_of_lt_pred strictAntiOn_Iic_of_lt_pred
+#align strict_anti_on_Ici_of_lt_pred strictAntiOn_Ici_of_lt_pred
 
 end SuccOrder

baba818b

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

4d06b17a

chore: Move intervals (#11765)

Move Set.Ixx, Finset.Ixx, Multiset.Ixx together under two different folders:

Order.Interval for their definition and basic properties
Algebra.Order.Interval for their algebraic properties

Move the definitions of Multiset.Ixx to what is now Order.Interval.Multiset. I believe we could just delete this file in a later PR as nothing uses it (and I already had doubts when defining Multiset.Ixx three years ago).

Move the algebraic results out of what is now Order.Interval.Finset.Basic to a new file Algebra.Order.Interval.Finset.Basic.

c7fa7063

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2021 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
-import Mathlib.Data.Set.Intervals.Disjoint
+import Mathlib.Order.Interval.Set.Disjoint
 import Mathlib.Order.SuccPred.Basic
 
 #align_import data.set.intervals.monotone from "leanprover-community/mathlib"@"4d06b17aea8cf2e220f0b0aa46cd0231593c5c97"

4d06b17a

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

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

This has nice performance benefits.

32de3f67

Diff

@@ -20,7 +20,7 @@ open Set
 
 section Ixx
 
-variable {α β : Type _} [Preorder α] [Preorder β] {f g : α → β} {s : Set α}
+variable {α β : Type*} [Preorder α] [Preorder β] {f g : α → β} {s : Set α}
 
 theorem antitone_Ici : Antitone (Ici : α → Set α) := fun _ _ => Ici_subset_Ici.2
 #align antitone_Ici antitone_Ici
@@ -182,7 +182,7 @@ end Ixx
 
 section iUnion
 
-variable {α β : Type _} [SemilatticeSup α] [LinearOrder β] {f g : α → β} {a b : β}
+variable {α β : Type*} [SemilatticeSup α] [LinearOrder β] {f g : α → β} {a b : β}
 
 theorem iUnion_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
     (ha : IsGLB (range f) a) (hb : IsLUB (range g) b) : ⋃ x, Ioo (f x) (g x) = Ioo a b :=
@@ -198,7 +198,7 @@ section SuccOrder
 
 open Order
 
-variable {α β : Type _} [PartialOrder α]
+variable {α β : Type*} [PartialOrder α]
 
 theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot α] {n : α} {φ : α → α}
     (hφ : StrictMonoOn φ (Set.Iic n)) : ∀ m ≤ n, m ≤ φ m := by

4d06b17a

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module data.set.intervals.monotone
-! leanprover-community/mathlib commit 4d06b17aea8cf2e220f0b0aa46cd0231593c5c97
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Intervals.Disjoint
 import Mathlib.Order.SuccPred.Basic
 
+#align_import data.set.intervals.monotone from "leanprover-community/mathlib"@"4d06b17aea8cf2e220f0b0aa46cd0231593c5c97"
+
 /-!
 # Monotonicity on intervals

4d06b17a

fix: precedences of ⨆⋃⋂⨅ (#5614)

e3c8f983

Diff

@@ -188,9 +188,9 @@ section iUnion
 variable {α β : Type _} [SemilatticeSup α] [LinearOrder β] {f g : α → β} {a b : β}
 
 theorem iUnion_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
-    (ha : IsGLB (range f) a) (hb : IsLUB (range g) b) : (⋃ x, Ioo (f x) (g x)) = Ioo a b :=
+    (ha : IsGLB (range f) a) (hb : IsLUB (range g) b) : ⋃ x, Ioo (f x) (g x) = Ioo a b :=
   calc
-    (⋃ x, Ioo (f x) (g x)) = (⋃ x, Ioi (f x)) ∩ ⋃ x, Iio (g x) :=
+    ⋃ x, Ioo (f x) (g x) = (⋃ x, Ioi (f x)) ∩ ⋃ x, Iio (g x) :=
       iUnion_inter_of_monotone hf.Ioi hg.Iio
     _ = Ioi a ∩ Iio b := congr_arg₂ (· ∩ ·) ha.iUnion_Ioi_eq hb.iUnion_Iio_eq
 #align Union_Ioo_of_mono_of_is_glb_of_is_lub iUnion_Ioo_of_mono_of_isGLB_of_isLUB

4d06b17a

fix precedence of Nat.iterate (#5589)

bd2fff86

Diff

@@ -240,10 +240,10 @@ theorem strictMonoOn_Iic_of_lt_succ [SuccOrder α] [IsSuccArchimedean α] {n : 
   · exact hψ _ (lt_of_lt_of_le hxy hy)
   rw [Set.mem_Iic] at *
   simp only [Function.iterate_succ', Function.comp_apply] at ih hxy hy ⊢
-  by_cases hmax : IsMax ((succ^[k]) x)
+  by_cases hmax : IsMax (succ^[k] x)
   · rw [succ_eq_iff_isMax.2 hmax] at hxy ⊢
     exact ih (le_trans (le_succ _) hy) hxy
-  by_cases hmax' : IsMax (succ ((succ^[k]) x))
+  by_cases hmax' : IsMax (succ (succ^[k] x))
   · rw [succ_eq_iff_isMax.2 hmax'] at hxy ⊢
     exact ih (le_trans (le_succ _) hy) hxy
   refine'

4d06b17a

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

Changes are of the form

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

2a870323

Diff

@@ -239,7 +239,7 @@ theorem strictMonoOn_Iic_of_lt_succ [SuccOrder α] [IsSuccArchimedean α] {n : 
   cases' k with k
   · exact hψ _ (lt_of_lt_of_le hxy hy)
   rw [Set.mem_Iic] at *
-  simp only [Function.iterate_succ', Function.comp_apply] at ih hxy hy⊢
+  simp only [Function.iterate_succ', Function.comp_apply] at ih hxy hy ⊢
   by_cases hmax : IsMax ((succ^[k]) x)
   · rw [succ_eq_iff_isMax.2 hmax] at hxy ⊢
     exact ih (le_trans (le_succ _) hy) hxy

4d06b17a

chore: Rename to sSup/iSup (#3938)

As discussed on Zulip

Renames

supₛ → sSup
infₛ → sInf
supᵢ → iSup
infᵢ → iInf
bsupₛ → bsSup
binfₛ → bsInf
bsupᵢ → biSup
binfᵢ → biInf
csupₛ → csSup
cinfₛ → csInf
csupᵢ → ciSup
cinfᵢ → ciInf
unionₛ → sUnion
interₛ → sInter
unionᵢ → iUnion
interᵢ → iInter
bunionₛ → bsUnion
binterₛ → bsInter
bunionᵢ → biUnion
binterᵢ → biInter

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

d1eb6264

Diff

@@ -183,19 +183,19 @@ protected theorem AntitoneOn.Ioo (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
 
 end Ixx
 
-section unionᵢ
+section iUnion
 
 variable {α β : Type _} [SemilatticeSup α] [LinearOrder β] {f g : α → β} {a b : β}
 
-theorem unionᵢ_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
+theorem iUnion_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
     (ha : IsGLB (range f) a) (hb : IsLUB (range g) b) : (⋃ x, Ioo (f x) (g x)) = Ioo a b :=
   calc
     (⋃ x, Ioo (f x) (g x)) = (⋃ x, Ioi (f x)) ∩ ⋃ x, Iio (g x) :=
-      unionᵢ_inter_of_monotone hf.Ioi hg.Iio
-    _ = Ioi a ∩ Iio b := congr_arg₂ (· ∩ ·) ha.unionᵢ_Ioi_eq hb.unionᵢ_Iio_eq
-#align Union_Ioo_of_mono_of_is_glb_of_is_lub unionᵢ_Ioo_of_mono_of_isGLB_of_isLUB
+      iUnion_inter_of_monotone hf.Ioi hg.Iio
+    _ = Ioi a ∩ Iio b := congr_arg₂ (· ∩ ·) ha.iUnion_Ioi_eq hb.iUnion_Iio_eq
+#align Union_Ioo_of_mono_of_is_glb_of_is_lub iUnion_Ioo_of_mono_of_isGLB_of_isLUB
 
-end unionᵢ
+end iUnion
 
 section SuccOrder

4d06b17a

chore: fix names (#3812)

Forward-port leanprover-community/mathlib#18921 and leanprover-community/mathlib#18924

cab52563

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 
 ! This file was ported from Lean 3 source module data.set.intervals.monotone
-! leanprover-community/mathlib commit 9aba7801eeecebb61f58a5763c2b6dd1b47dc6ef
+! leanprover-community/mathlib commit 4d06b17aea8cf2e220f0b0aa46cd0231593c5c97
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -221,10 +221,10 @@ theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot 
   · exact ih (StrictMonoOn.mono hφ fun x hx => le_trans hx (le_succ _)) _ h
 #align strict_mono_on.Iic_id_le StrictMonoOn.Iic_id_le
 
-theorem StrictMonoOn.Iic_le_id [PredOrder α] [IsPredArchimedean α] [OrderTop α] {n : α} {φ : α → α}
+theorem StrictMonoOn.Ici_le_id [PredOrder α] [IsPredArchimedean α] [OrderTop α] {n : α} {φ : α → α}
     (hφ : StrictMonoOn φ (Set.Ici n)) : ∀ m, n ≤ m → φ m ≤ m :=
   StrictMonoOn.Iic_id_le (α := αᵒᵈ) fun _ hi _ hj hij => hφ hj hi hij
-#align strict_mono_on.Iic_le_id StrictMonoOn.Iic_le_id
+#align strict_mono_on.Ici_le_id StrictMonoOn.Ici_le_id
 
 variable [Preorder β] {ψ : α → β}
 
@@ -261,14 +261,14 @@ theorem strictAntiOn_Iic_of_succ_lt [SuccOrder α] [IsSuccArchimedean α] {n : 
   @strictMonoOn_Iic_of_lt_succ α βᵒᵈ _ _ ψ _ _ n hψ i hi j hj hij
 #align strict_anti_on_Iic_of_succ_lt strictAntiOn_Iic_of_succ_lt
 
-theorem strictMonoOn_Iic_of_pred_lt [PredOrder α] [IsPredArchimedean α] {n : α}
+theorem strictMonoOn_Ici_of_pred_lt [PredOrder α] [IsPredArchimedean α] {n : α}
     (hψ : ∀ m, n < m → ψ (pred m) < ψ m) : StrictMonoOn ψ (Set.Ici n) := fun i hi j hj hij =>
   @strictMonoOn_Iic_of_lt_succ αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij
-#align strict_mono_on_Iic_of_pred_lt strictMonoOn_Iic_of_pred_lt
+#align strict_mono_on_Ici_of_pred_lt strictMonoOn_Ici_of_pred_lt
 
-theorem strictAntiOn_Iic_of_lt_pred [PredOrder α] [IsPredArchimedean α] {n : α}
+theorem strictAntiOn_Ici_of_lt_pred [PredOrder α] [IsPredArchimedean α] {n : α}
     (hψ : ∀ m, n < m → ψ m < ψ (pred m)) : StrictAntiOn ψ (Set.Ici n) := fun i hi j hj hij =>
   @strictAntiOn_Iic_of_succ_lt αᵒᵈ βᵒᵈ _ _ ψ _ _ n hψ j hj i hi hij
-#align strict_anti_on_Iic_of_lt_pred strictAntiOn_Iic_of_lt_pred
+#align strict_anti_on_Ici_of_lt_pred strictAntiOn_Ici_of_lt_pred
 
 end SuccOrder

9aba7801

Refactor uses to rename_i that have easy fixes (#2429)

ffbbaaae

Diff

@@ -236,9 +236,8 @@ theorem strictMonoOn_Iic_of_lt_succ [SuccOrder α] [IsSuccArchimedean α] {n : 
   obtain ⟨i, rfl⟩ := hxy.le.exists_succ_iterate
   induction' i with k ih
   · simp at hxy
-  cases k
+  cases' k with k
   · exact hψ _ (lt_of_lt_of_le hxy hy)
-  rename_i k
   rw [Set.mem_Iic] at *
   simp only [Function.iterate_succ', Function.comp_apply] at ih hxy hy⊢
   by_cases hmax : IsMax ((succ^[k]) x)

9aba7801

chore: format by line breaks (#1523)

During porting, I usually fix the desired format we seem to want for the line breaks around by with

awk '{do {{if (match($0, "^  by$") && length(p) < 98) {p=p " by";} else {if (NR!=1) {print p}; p=$0}}} while (getline == 1) if (getline==0) print p}' Mathlib/File/Im/Working/On.lean

I noticed there are some more files that slipped through.

This pull request is the result of running this command:

grep -lr "^  by\$" Mathlib | xargs -n 1 awk -i inplace '{do {{if (match($0, "^  by$") && length(p) < 98 && not (match(p, "^[ \t]*--"))) {p=p " by";} else {if (NR!=1) {print p}; p=$0}}} while (getline == 1) if (getline==0) print p}'

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

d6d859a7

Diff

@@ -204,8 +204,7 @@ open Order
 variable {α β : Type _} [PartialOrder α]
 
 theorem StrictMonoOn.Iic_id_le [SuccOrder α] [IsSuccArchimedean α] [OrderBot α] {n : α} {φ : α → α}
-    (hφ : StrictMonoOn φ (Set.Iic n)) : ∀ m ≤ n, m ≤ φ m :=
-  by
+    (hφ : StrictMonoOn φ (Set.Iic n)) : ∀ m ≤ n, m ≤ φ m := by
   revert hφ
   refine'
     Succ.rec_bot (fun n => StrictMonoOn φ (Set.Iic n) → ∀ m ≤ n, m ≤ φ m)
@@ -232,8 +231,7 @@ variable [Preorder β] {ψ : α → β}
 /-- A function `ψ` on a `SuccOrder` is strictly monotone before some `n` if for all `m` such that
 `m < n`, we have `ψ m < ψ (succ m)`. -/
 theorem strictMonoOn_Iic_of_lt_succ [SuccOrder α] [IsSuccArchimedean α] {n : α}
-    (hψ : ∀ m, m < n → ψ m < ψ (succ m)) : StrictMonoOn ψ (Set.Iic n) :=
-  by
+    (hψ : ∀ m, m < n → ψ m < ψ (succ m)) : StrictMonoOn ψ (Set.Iic n) := by
   intro x hx y hy hxy
   obtain ⟨i, rfl⟩ := hxy.le.exists_succ_iterate
   induction' i with k ih

9aba7801

feat: port Data.Set.Intervals.Monotone (#1294)

Surprising tricky for a beginner O_O -- had to figure out that rename_i was a thing.

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com>

95c8c7e5

`data.set.intervals.monotone` ⟷ `Mathlib.Data.Set.Intervals.Monotone`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 69

data.set.intervals.monotone ⟷ Mathlib.Data.Set.Intervals.Monotone

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 69

`data.set.intervals.monotone` ⟷ `Mathlib.Data.Set.Intervals.Monotone`