data.set.intervals.disjoint ⟷ Mathlib.Data.Set.Intervals.Disjoint

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

@@ -188,7 +188,7 @@ theorem Ioc_disjoint_Ioc : Disjoint (Ioc a₁ a₂) (Ioc b₁ b₂) ↔ min a₂
 theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x₂) (Ico y₁ y₂)) (hx : x₁ < x₂)
     (h2 : x₂ ∈ Ico y₁ y₂) : y₁ = x₂ :=
   by
-  rw [Ico_disjoint_Ico, min_eq_left (le_of_lt h2.2), le_max_iff] at h 
+  rw [Ico_disjoint_Ico, min_eq_left (le_of_lt h2.2), le_max_iff] at h
   apply le_antisymm h2.1
   exact h.elim (fun h => absurd hx (not_lt_of_le h)) id
 #align set.eq_of_Ico_disjoint Set.eq_of_Ico_disjoint

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

@@ -3,7 +3,7 @@ Copyright (c) 2019 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn, Yury Kudryashov
 -/
-import Mathbin.Data.Set.Lattice
+import Data.Set.Lattice
 
 #align_import data.set.intervals.disjoint from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
 

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

@@ -2,14 +2,11 @@
 Copyright (c) 2019 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn, Yury Kudryashov
-
-! This file was ported from Lean 3 source module data.set.intervals.disjoint
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Lattice
 
+#align_import data.set.intervals.disjoint from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
+
 /-!
 # Extra lemmas about intervals
 

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

@@ -36,35 +36,47 @@ section Preorder
 
 variable [Preorder α] {a b c : α}
 
+#print Set.Iic_disjoint_Ioi /-
 @[simp]
 theorem Iic_disjoint_Ioi (h : a ≤ b) : Disjoint (Iic a) (Ioi b) :=
   disjoint_left.mpr fun x ha hb => (h.trans_lt hb).not_le ha
 #align set.Iic_disjoint_Ioi Set.Iic_disjoint_Ioi
+-/
 
+#print Set.Iic_disjoint_Ioc /-
 @[simp]
 theorem Iic_disjoint_Ioc (h : a ≤ b) : Disjoint (Iic a) (Ioc b c) :=
   (Iic_disjoint_Ioi h).mono le_rfl fun _ => And.left
 #align set.Iic_disjoint_Ioc Set.Iic_disjoint_Ioc
+-/
 
+#print Set.Ioc_disjoint_Ioc_same /-
 @[simp]
 theorem Ioc_disjoint_Ioc_same {a b c : α} : Disjoint (Ioc a b) (Ioc b c) :=
   (Iic_disjoint_Ioc (le_refl b)).mono (fun _ => And.right) le_rfl
 #align set.Ioc_disjoint_Ioc_same Set.Ioc_disjoint_Ioc_same
+-/
 
+#print Set.Ico_disjoint_Ico_same /-
 @[simp]
 theorem Ico_disjoint_Ico_same {a b c : α} : Disjoint (Ico a b) (Ico b c) :=
   disjoint_left.mpr fun x hab hbc => hab.2.not_le hbc.1
 #align set.Ico_disjoint_Ico_same Set.Ico_disjoint_Ico_same
+-/
 
+#print Set.Ici_disjoint_Iic /-
 @[simp]
 theorem Ici_disjoint_Iic : Disjoint (Ici a) (Iic b) ↔ ¬a ≤ b := by
   rw [Set.disjoint_iff_inter_eq_empty, Ici_inter_Iic, Icc_eq_empty_iff]
 #align set.Ici_disjoint_Iic Set.Ici_disjoint_Iic
+-/
 
+#print Set.Iic_disjoint_Ici /-
 @[simp]
 theorem Iic_disjoint_Ici : Disjoint (Iic a) (Ici b) ↔ ¬b ≤ a :=
   disjoint_comm.trans Ici_disjoint_Iic
 #align set.Iic_disjoint_Ici Set.Iic_disjoint_Ici
+-/
 
 #print Set.iUnion_Iic /-
 @[simp]
@@ -156,19 +168,24 @@ section LinearOrder
 
 variable [LinearOrder α] {a₁ a₂ b₁ b₂ : α}
 
+#print Set.Ico_disjoint_Ico /-
 @[simp]
 theorem Ico_disjoint_Ico : Disjoint (Ico a₁ a₂) (Ico b₁ b₂) ↔ min a₂ b₂ ≤ max a₁ b₁ := by
   simp_rw [Set.disjoint_iff_inter_eq_empty, Ico_inter_Ico, Ico_eq_empty_iff, inf_eq_min, sup_eq_max,
     not_lt]
 #align set.Ico_disjoint_Ico Set.Ico_disjoint_Ico
+-/
 
+#print Set.Ioc_disjoint_Ioc /-
 @[simp]
 theorem Ioc_disjoint_Ioc : Disjoint (Ioc a₁ a₂) (Ioc b₁ b₂) ↔ min a₂ b₂ ≤ max a₁ b₁ :=
   by
   have h : _ ↔ min (toDual a₁) (toDual b₁) ≤ max (toDual a₂) (toDual b₂) := Ico_disjoint_Ico
   simpa only [dual_Ico] using h
 #align set.Ioc_disjoint_Ioc Set.Ioc_disjoint_Ioc
+-/
 
+#print Set.eq_of_Ico_disjoint /-
 /-- If two half-open intervals are disjoint and the endpoint of one lies in the other,
   then it must be equal to the endpoint of the other. -/
 theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x₂) (Ico y₁ y₂)) (hx : x₁ < x₂)
@@ -178,6 +195,7 @@ theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x
   apply le_antisymm h2.1
   exact h.elim (fun h => absurd hx (not_lt_of_le h)) id
 #align set.eq_of_Ico_disjoint Set.eq_of_Ico_disjoint
+-/
 
 #print Set.iUnion_Ico_eq_Iio_self_iff /-
 @[simp]
@@ -282,27 +300,35 @@ theorem IsLUB.biUnion_Iic_eq_Iic (a_lub : IsLUB s a) (a_mem : a ∈ s) : (⋃ x
 #align is_lub.bUnion_Iic_eq_Iic IsLUB.biUnion_Iic_eq_Iic
 -/
 
+#print iUnion_Ici_eq_Ioi_iInf /-
 theorem iUnion_Ici_eq_Ioi_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (no_least_elem : (⨅ i, f i) ∉ range f) : (⋃ i : ι, Ici (f i)) = Ioi (⨅ i, f i) := by
   simp only [← IsGLB.biUnion_Ici_eq_Ioi (@isGLB_iInf _ _ _ f) no_least_elem, mem_range,
     Union_exists, Union_Union_eq']
 #align Union_Ici_eq_Ioi_infi iUnion_Ici_eq_Ioi_iInf
+-/
 
+#print iUnion_Iic_eq_Iio_iSup /-
 theorem iUnion_Iic_eq_Iio_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (no_greatest_elem : (⨆ i, f i) ∉ range f) : (⋃ i : ι, Iic (f i)) = Iio (⨆ i, f i) :=
   @iUnion_Ici_eq_Ioi_iInf ι (OrderDual R) _ f no_greatest_elem
 #align Union_Iic_eq_Iio_supr iUnion_Iic_eq_Iio_iSup
+-/
 
+#print iUnion_Ici_eq_Ici_iInf /-
 theorem iUnion_Ici_eq_Ici_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (has_least_elem : (⨅ i, f i) ∈ range f) : (⋃ i : ι, Ici (f i)) = Ici (⨅ i, f i) := by
   simp only [← IsGLB.biUnion_Ici_eq_Ici (@isGLB_iInf _ _ _ f) has_least_elem, mem_range,
     Union_exists, Union_Union_eq']
 #align Union_Ici_eq_Ici_infi iUnion_Ici_eq_Ici_iInf
+-/
 
+#print iUnion_Iic_eq_Iic_iSup /-
 theorem iUnion_Iic_eq_Iic_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (has_greatest_elem : (⨆ i, f i) ∈ range f) : (⋃ i : ι, Iic (f i)) = Iic (⨆ i, f i) :=
   @iUnion_Ici_eq_Ici_iInf ι (OrderDual R) _ f has_greatest_elem
 #align Union_Iic_eq_Iic_supr iUnion_Iic_eq_Iic_iSup
+-/
 
 end UnionIxx
 

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

@@ -174,7 +174,7 @@ theorem Ioc_disjoint_Ioc : Disjoint (Ioc a₁ a₂) (Ioc b₁ b₂) ↔ min a₂
 theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x₂) (Ico y₁ y₂)) (hx : x₁ < x₂)
     (h2 : x₂ ∈ Ico y₁ y₂) : y₁ = x₂ :=
   by
-  rw [Ico_disjoint_Ico, min_eq_left (le_of_lt h2.2), le_max_iff] at h
+  rw [Ico_disjoint_Ico, min_eq_left (le_of_lt h2.2), le_max_iff] at h 
   apply le_antisymm h2.1
   exact h.elim (fun h => absurd hx (not_lt_of_le h)) id
 #align set.eq_of_Ico_disjoint Set.eq_of_Ico_disjoint

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

@@ -108,35 +108,47 @@ theorem iUnion_Ico_left (b : α) : (⋃ a, Ico a b) = Iio b := by
 #align set.Union_Ico_left Set.iUnion_Ico_left
 -/
 
+#print Set.iUnion_Iio /-
 @[simp]
 theorem iUnion_Iio [NoMaxOrder α] : (⋃ a : α, Iio a) = univ :=
   iUnion_eq_univ_iff.2 exists_gt
 #align set.Union_Iio Set.iUnion_Iio
+-/
 
+#print Set.iUnion_Ioi /-
 @[simp]
 theorem iUnion_Ioi [NoMinOrder α] : (⋃ a : α, Ioi a) = univ :=
   iUnion_eq_univ_iff.2 exists_lt
 #align set.Union_Ioi Set.iUnion_Ioi
+-/
 
+#print Set.iUnion_Ico_right /-
 @[simp]
 theorem iUnion_Ico_right [NoMaxOrder α] (a : α) : (⋃ b, Ico a b) = Ici a := by
   simp only [← Ici_inter_Iio, ← inter_Union, Union_Iio, inter_univ]
 #align set.Union_Ico_right Set.iUnion_Ico_right
+-/
 
+#print Set.iUnion_Ioo_right /-
 @[simp]
 theorem iUnion_Ioo_right [NoMaxOrder α] (a : α) : (⋃ b, Ioo a b) = Ioi a := by
   simp only [← Ioi_inter_Iio, ← inter_Union, Union_Iio, inter_univ]
 #align set.Union_Ioo_right Set.iUnion_Ioo_right
+-/
 
+#print Set.iUnion_Ioc_left /-
 @[simp]
 theorem iUnion_Ioc_left [NoMinOrder α] (b : α) : (⋃ a, Ioc a b) = Iic b := by
   simp only [← Ioi_inter_Iic, ← Union_inter, Union_Ioi, univ_inter]
 #align set.Union_Ioc_left Set.iUnion_Ioc_left
+-/
 
+#print Set.iUnion_Ioo_left /-
 @[simp]
 theorem iUnion_Ioo_left [NoMinOrder α] (b : α) : (⋃ a, Ioo a b) = Iio b := by
   simp only [← Ioi_inter_Iio, ← Union_inter, Union_Ioi, univ_inter]
 #align set.Union_Ioo_left Set.iUnion_Ioo_left
+-/
 
 end Preorder
 
@@ -167,29 +179,37 @@ theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x
   exact h.elim (fun h => absurd hx (not_lt_of_le h)) id
 #align set.eq_of_Ico_disjoint Set.eq_of_Ico_disjoint
 
+#print Set.iUnion_Ico_eq_Iio_self_iff /-
 @[simp]
 theorem iUnion_Ico_eq_Iio_self_iff {f : ι → α} {a : α} :
     (⋃ i, Ico (f i) a) = Iio a ↔ ∀ x < a, ∃ i, f i ≤ x := by
   simp [← Ici_inter_Iio, ← Union_inter, subset_def]
 #align set.Union_Ico_eq_Iio_self_iff Set.iUnion_Ico_eq_Iio_self_iff
+-/
 
+#print Set.iUnion_Ioc_eq_Ioi_self_iff /-
 @[simp]
 theorem iUnion_Ioc_eq_Ioi_self_iff {f : ι → α} {a : α} :
     (⋃ i, Ioc a (f i)) = Ioi a ↔ ∀ x, a < x → ∃ i, x ≤ f i := by
   simp [← Ioi_inter_Iic, ← inter_Union, subset_def]
 #align set.Union_Ioc_eq_Ioi_self_iff Set.iUnion_Ioc_eq_Ioi_self_iff
+-/
 
+#print Set.biUnion_Ico_eq_Iio_self_iff /-
 @[simp]
 theorem biUnion_Ico_eq_Iio_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
     (⋃ (i) (hi : p i), Ico (f i hi) a) = Iio a ↔ ∀ x < a, ∃ i hi, f i hi ≤ x := by
   simp [← Ici_inter_Iio, ← Union_inter, subset_def]
 #align set.bUnion_Ico_eq_Iio_self_iff Set.biUnion_Ico_eq_Iio_self_iff
+-/
 
+#print Set.biUnion_Ioc_eq_Ioi_self_iff /-
 @[simp]
 theorem biUnion_Ioc_eq_Ioi_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
     (⋃ (i) (hi : p i), Ioc a (f i hi)) = Ioi a ↔ ∀ x, a < x → ∃ i hi, x ≤ f i hi := by
   simp [← Ioi_inter_Iic, ← inter_Union, subset_def]
 #align set.bUnion_Ioc_eq_Ioi_self_iff Set.biUnion_Ioc_eq_Ioi_self_iff
+-/
 
 end LinearOrder
 

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

@@ -36,67 +36,31 @@ section Preorder
 
 variable [Preorder α] {a b c : α}
 
-/- warning: set.Iic_disjoint_Ioi -> Set.Iic_disjoint_Ioi is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Iic.{u1} α _inst_1 a) (Set.Ioi.{u1} α _inst_1 b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{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 a) (Set.Ioi.{u1} α _inst_1 b))
-Case conversion may be inaccurate. Consider using '#align set.Iic_disjoint_Ioi Set.Iic_disjoint_Ioiₓ'. -/
 @[simp]
 theorem Iic_disjoint_Ioi (h : a ≤ b) : Disjoint (Iic a) (Ioi b) :=
   disjoint_left.mpr fun x ha hb => (h.trans_lt hb).not_le ha
 #align set.Iic_disjoint_Ioi Set.Iic_disjoint_Ioi
 
-/- warning: set.Iic_disjoint_Ioc -> Set.Iic_disjoint_Ioc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {c : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Iic.{u1} α _inst_1 a) (Set.Ioc.{u1} α _inst_1 b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {c : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{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 a) (Set.Ioc.{u1} α _inst_1 b c))
-Case conversion may be inaccurate. Consider using '#align set.Iic_disjoint_Ioc Set.Iic_disjoint_Iocₓ'. -/
 @[simp]
 theorem Iic_disjoint_Ioc (h : a ≤ b) : Disjoint (Iic a) (Ioc b c) :=
   (Iic_disjoint_Ioi h).mono le_rfl fun _ => And.left
 #align set.Iic_disjoint_Ioc Set.Iic_disjoint_Ioc
 
-/- warning: set.Ioc_disjoint_Ioc_same -> Set.Ioc_disjoint_Ioc_same is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {c : α}, Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ioc.{u1} α _inst_1 a b) (Set.Ioc.{u1} α _inst_1 b c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {c : α}, Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Set.Ioc.{u1} α _inst_1 a b) (Set.Ioc.{u1} α _inst_1 b c)
-Case conversion may be inaccurate. Consider using '#align set.Ioc_disjoint_Ioc_same Set.Ioc_disjoint_Ioc_sameₓ'. -/
 @[simp]
 theorem Ioc_disjoint_Ioc_same {a b c : α} : Disjoint (Ioc a b) (Ioc b c) :=
   (Iic_disjoint_Ioc (le_refl b)).mono (fun _ => And.right) le_rfl
 #align set.Ioc_disjoint_Ioc_same Set.Ioc_disjoint_Ioc_same
 
-/- warning: set.Ico_disjoint_Ico_same -> Set.Ico_disjoint_Ico_same is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {c : α}, Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ico.{u1} α _inst_1 a b) (Set.Ico.{u1} α _inst_1 b c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {c : α}, Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Set.Ico.{u1} α _inst_1 a b) (Set.Ico.{u1} α _inst_1 b c)
-Case conversion may be inaccurate. Consider using '#align set.Ico_disjoint_Ico_same Set.Ico_disjoint_Ico_sameₓ'. -/
 @[simp]
 theorem Ico_disjoint_Ico_same {a b c : α} : Disjoint (Ico a b) (Ico b c) :=
   disjoint_left.mpr fun x hab hbc => hab.2.not_le hbc.1
 #align set.Ico_disjoint_Ico_same Set.Ico_disjoint_Ico_same
 
-/- warning: set.Ici_disjoint_Iic -> Set.Ici_disjoint_Iic is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ici.{u1} α _inst_1 a) (Set.Iic.{u1} α _inst_1 b)) (Not (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{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 a) (Set.Iic.{u1} α _inst_1 b)) (Not (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align set.Ici_disjoint_Iic Set.Ici_disjoint_Iicₓ'. -/
 @[simp]
 theorem Ici_disjoint_Iic : Disjoint (Ici a) (Iic b) ↔ ¬a ≤ b := by
   rw [Set.disjoint_iff_inter_eq_empty, Ici_inter_Iic, Icc_eq_empty_iff]
 #align set.Ici_disjoint_Iic Set.Ici_disjoint_Iic
 
-/- warning: set.Iic_disjoint_Ici -> Set.Iic_disjoint_Ici is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Iic.{u1} α _inst_1 a) (Set.Ici.{u1} α _inst_1 b)) (Not (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{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 a) (Set.Ici.{u1} α _inst_1 b)) (Not (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a))
-Case conversion may be inaccurate. Consider using '#align set.Iic_disjoint_Ici Set.Iic_disjoint_Iciₓ'. -/
 @[simp]
 theorem Iic_disjoint_Ici : Disjoint (Iic a) (Ici b) ↔ ¬b ≤ a :=
   disjoint_comm.trans Ici_disjoint_Iic
@@ -144,67 +108,31 @@ theorem iUnion_Ico_left (b : α) : (⋃ a, Ico a b) = Iio b := by
 #align set.Union_Ico_left Set.iUnion_Ico_left
 -/
 
-/- warning: set.Union_Iio -> Set.iUnion_Iio is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Iio.{u1} α _inst_1 a)) (Set.univ.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Iio.{u1} α _inst_1 a)) (Set.univ.{u1} α)
-Case conversion may be inaccurate. Consider using '#align set.Union_Iio Set.iUnion_Iioₓ'. -/
 @[simp]
 theorem iUnion_Iio [NoMaxOrder α] : (⋃ a : α, Iio a) = univ :=
   iUnion_eq_univ_iff.2 exists_gt
 #align set.Union_Iio Set.iUnion_Iio
 
-/- warning: set.Union_Ioi -> Set.iUnion_Ioi is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioi.{u1} α _inst_1 a)) (Set.univ.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioi.{u1} α _inst_1 a)) (Set.univ.{u1} α)
-Case conversion may be inaccurate. Consider using '#align set.Union_Ioi Set.iUnion_Ioiₓ'. -/
 @[simp]
 theorem iUnion_Ioi [NoMinOrder α] : (⋃ a : α, Ioi a) = univ :=
   iUnion_eq_univ_iff.2 exists_lt
 #align set.Union_Ioi Set.iUnion_Ioi
 
-/- warning: set.Union_Ico_right -> Set.iUnion_Ico_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.Ico.{u1} α _inst_1 a b)) (Set.Ici.{u1} α _inst_1 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.Ico.{u1} α _inst_1 a b)) (Set.Ici.{u1} α _inst_1 a)
-Case conversion may be inaccurate. Consider using '#align set.Union_Ico_right Set.iUnion_Ico_rightₓ'. -/
 @[simp]
 theorem iUnion_Ico_right [NoMaxOrder α] (a : α) : (⋃ b, Ico a b) = Ici a := by
   simp only [← Ici_inter_Iio, ← inter_Union, Union_Iio, inter_univ]
 #align set.Union_Ico_right Set.iUnion_Ico_right
 
-/- warning: set.Union_Ioo_right -> Set.iUnion_Ioo_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.Ioo.{u1} α _inst_1 a b)) (Set.Ioi.{u1} α _inst_1 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.Ioo.{u1} α _inst_1 a b)) (Set.Ioi.{u1} α _inst_1 a)
-Case conversion may be inaccurate. Consider using '#align set.Union_Ioo_right Set.iUnion_Ioo_rightₓ'. -/
 @[simp]
 theorem iUnion_Ioo_right [NoMaxOrder α] (a : α) : (⋃ b, Ioo a b) = Ioi a := by
   simp only [← Ioi_inter_Iio, ← inter_Union, Union_Iio, inter_univ]
 #align set.Union_Ioo_right Set.iUnion_Ioo_right
 
-/- warning: set.Union_Ioc_left -> Set.iUnion_Ioc_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (b : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioc.{u1} α _inst_1 a b)) (Set.Iic.{u1} α _inst_1 b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (b : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioc.{u1} α _inst_1 a b)) (Set.Iic.{u1} α _inst_1 b)
-Case conversion may be inaccurate. Consider using '#align set.Union_Ioc_left Set.iUnion_Ioc_leftₓ'. -/
 @[simp]
 theorem iUnion_Ioc_left [NoMinOrder α] (b : α) : (⋃ a, Ioc a b) = Iic b := by
   simp only [← Ioi_inter_Iic, ← Union_inter, Union_Ioi, univ_inter]
 #align set.Union_Ioc_left Set.iUnion_Ioc_left
 
-/- warning: set.Union_Ioo_left -> Set.iUnion_Ioo_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (b : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioo.{u1} α _inst_1 a b)) (Set.Iio.{u1} α _inst_1 b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (b : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioo.{u1} α _inst_1 a b)) (Set.Iio.{u1} α _inst_1 b)
-Case conversion may be inaccurate. Consider using '#align set.Union_Ioo_left Set.iUnion_Ioo_leftₓ'. -/
 @[simp]
 theorem iUnion_Ioo_left [NoMinOrder α] (b : α) : (⋃ a, Ioo a b) = Iio b := by
   simp only [← Ioi_inter_Iio, ← Union_inter, Union_Ioi, univ_inter]
@@ -216,24 +144,12 @@ section LinearOrder
 
 variable [LinearOrder α] {a₁ a₂ b₁ b₂ : α}
 
-/- warning: set.Ico_disjoint_Ico -> Set.Ico_disjoint_Ico is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a₁ a₂) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b₁ b₂)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a₂ b₂) (LinearOrder.max.{u1} α _inst_1 a₁ b₁))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) a₁ a₂) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) b₁ b₂)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a₂ b₂) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a₁ b₁))
-Case conversion may be inaccurate. Consider using '#align set.Ico_disjoint_Ico Set.Ico_disjoint_Icoₓ'. -/
 @[simp]
 theorem Ico_disjoint_Ico : Disjoint (Ico a₁ a₂) (Ico b₁ b₂) ↔ min a₂ b₂ ≤ max a₁ b₁ := by
   simp_rw [Set.disjoint_iff_inter_eq_empty, Ico_inter_Ico, Ico_eq_empty_iff, inf_eq_min, sup_eq_max,
     not_lt]
 #align set.Ico_disjoint_Ico Set.Ico_disjoint_Ico
 
-/- warning: set.Ioc_disjoint_Ioc -> Set.Ioc_disjoint_Ioc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a₁ a₂) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b₁ b₂)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a₂ b₂) (LinearOrder.max.{u1} α _inst_1 a₁ b₁))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) a₁ a₂) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) b₁ b₂)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a₂ b₂) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a₁ b₁))
-Case conversion may be inaccurate. Consider using '#align set.Ioc_disjoint_Ioc Set.Ioc_disjoint_Iocₓ'. -/
 @[simp]
 theorem Ioc_disjoint_Ioc : Disjoint (Ioc a₁ a₂) (Ioc b₁ b₂) ↔ min a₂ b₂ ≤ max a₁ b₁ :=
   by
@@ -241,12 +157,6 @@ theorem Ioc_disjoint_Ioc : Disjoint (Ioc a₁ a₂) (Ioc b₁ b₂) ↔ min a₂
   simpa only [dual_Ico] using h
 #align set.Ioc_disjoint_Ioc Set.Ioc_disjoint_Ioc
 
-/- warning: set.eq_of_Ico_disjoint -> Set.eq_of_Ico_disjoint is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x₁ : α} {x₂ : α} {y₁ : α} {y₂ : α}, (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) x₁ x₂) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) y₁ y₂)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) x₁ x₂) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x₂ (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) y₁ y₂)) -> (Eq.{succ u1} α y₁ x₂)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x₁ : α} {x₂ : α} {y₁ : α} {y₂ : α}, (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) x₁ x₂) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) y₁ y₂)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x₁ x₂) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x₂ (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) y₁ y₂)) -> (Eq.{succ u1} α y₁ x₂)
-Case conversion may be inaccurate. Consider using '#align set.eq_of_Ico_disjoint Set.eq_of_Ico_disjointₓ'. -/
 /-- If two half-open intervals are disjoint and the endpoint of one lies in the other,
   then it must be equal to the endpoint of the other. -/
 theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x₂) (Ico y₁ y₂)) (hx : x₁ < x₂)
@@ -257,48 +167,24 @@ theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x
   exact h.elim (fun h => absurd hx (not_lt_of_le h)) id
 #align set.eq_of_Ico_disjoint Set.eq_of_Ico_disjoint
 
-/- warning: set.Union_Ico_eq_Iio_self_iff -> Set.iUnion_Ico_eq_Iio_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {f : ι -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) (f i) a)) (Set.Iio.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) x a) -> (Exists.{u1} ι (fun (i : ι) => LE.le.{u2} α (Preorder.toHasLe.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) (f i) x)))
-but is expected to have type
-  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {f : ι -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) (f i) a)) (Set.Iio.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) x a) -> (Exists.{u1} ι (fun (i : ι) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) (f i) x)))
-Case conversion may be inaccurate. Consider using '#align set.Union_Ico_eq_Iio_self_iff Set.iUnion_Ico_eq_Iio_self_iffₓ'. -/
 @[simp]
 theorem iUnion_Ico_eq_Iio_self_iff {f : ι → α} {a : α} :
     (⋃ i, Ico (f i) a) = Iio a ↔ ∀ x < a, ∃ i, f i ≤ x := by
   simp [← Ici_inter_Iio, ← Union_inter, subset_def]
 #align set.Union_Ico_eq_Iio_self_iff Set.iUnion_Ico_eq_Iio_self_iff
 
-/- warning: set.Union_Ioc_eq_Ioi_self_iff -> Set.iUnion_Ioc_eq_Ioi_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {f : ι -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a (f i))) (Set.Ioi.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) a x) -> (Exists.{u1} ι (fun (i : ι) => LE.le.{u2} α (Preorder.toHasLe.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) x (f i))))
-but is expected to have type
-  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {f : ι -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a (f i))) (Set.Ioi.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) a x) -> (Exists.{u1} ι (fun (i : ι) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) x (f i))))
-Case conversion may be inaccurate. Consider using '#align set.Union_Ioc_eq_Ioi_self_iff Set.iUnion_Ioc_eq_Ioi_self_iffₓ'. -/
 @[simp]
 theorem iUnion_Ioc_eq_Ioi_self_iff {f : ι → α} {a : α} :
     (⋃ i, Ioc a (f i)) = Ioi a ↔ ∀ x, a < x → ∃ i, x ≤ f i := by
   simp [← Ioi_inter_Iic, ← inter_Union, subset_def]
 #align set.Union_Ioc_eq_Ioi_self_iff Set.iUnion_Ioc_eq_Ioi_self_iff
 
-/- warning: set.bUnion_Ico_eq_Iio_self_iff -> Set.biUnion_Ico_eq_Iio_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {p : ι -> Prop} {f : forall (i : ι), (p i) -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (p i) (fun (hi : p i) => Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) (f i hi) a))) (Set.Iio.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) x a) -> (Exists.{u1} ι (fun (i : ι) => Exists.{0} (p i) (fun (hi : p i) => LE.le.{u2} α (Preorder.toHasLe.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) (f i hi) x))))
-but is expected to have type
-  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {p : ι -> Prop} {f : forall (i : ι), (p i) -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (p i) (fun (hi : p i) => Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) (f i hi) a))) (Set.Iio.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) x a) -> (Exists.{u1} ι (fun (i : ι) => Exists.{0} (p i) (fun (hi : p i) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) (f i hi) x))))
-Case conversion may be inaccurate. Consider using '#align set.bUnion_Ico_eq_Iio_self_iff Set.biUnion_Ico_eq_Iio_self_iffₓ'. -/
 @[simp]
 theorem biUnion_Ico_eq_Iio_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
     (⋃ (i) (hi : p i), Ico (f i hi) a) = Iio a ↔ ∀ x < a, ∃ i hi, f i hi ≤ x := by
   simp [← Ici_inter_Iio, ← Union_inter, subset_def]
 #align set.bUnion_Ico_eq_Iio_self_iff Set.biUnion_Ico_eq_Iio_self_iff
 
-/- warning: set.bUnion_Ioc_eq_Ioi_self_iff -> Set.biUnion_Ioc_eq_Ioi_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {p : ι -> Prop} {f : forall (i : ι), (p i) -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (p i) (fun (hi : p i) => Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a (f i hi)))) (Set.Ioi.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) a x) -> (Exists.{u1} ι (fun (i : ι) => Exists.{0} (p i) (fun (hi : p i) => LE.le.{u2} α (Preorder.toHasLe.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) x (f i hi)))))
-but is expected to have type
-  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {p : ι -> Prop} {f : forall (i : ι), (p i) -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (p i) (fun (hi : p i) => Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a (f i hi)))) (Set.Ioi.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) a x) -> (Exists.{u1} ι (fun (i : ι) => Exists.{0} (p i) (fun (hi : p i) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) x (f i hi)))))
-Case conversion may be inaccurate. Consider using '#align set.bUnion_Ioc_eq_Ioi_self_iff Set.biUnion_Ioc_eq_Ioi_self_iffₓ'. -/
 @[simp]
 theorem biUnion_Ioc_eq_Ioi_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
     (⋃ (i) (hi : p i), Ioc a (f i hi)) = Ioi a ↔ ∀ x, a < x → ∃ i hi, x ≤ f i hi := by
@@ -376,47 +262,23 @@ theorem IsLUB.biUnion_Iic_eq_Iic (a_lub : IsLUB s a) (a_mem : a ∈ s) : (⋃ x
 #align is_lub.bUnion_Iic_eq_Iic IsLUB.biUnion_Iic_eq_Iic
 -/
 
-/- warning: Union_Ici_eq_Ioi_infi -> iUnion_Ici_eq_Ioi_iInf is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Not (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (iInf.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f))) -> (Eq.{succ u2} (Set.{u2} R) (Set.iUnion.{u2, u1} R ι (fun (i : ι) => Set.Ici.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Ioi.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (iInf.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
-but is expected to have type
-  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Not (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (iInf.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f))) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, u2} R ι (fun (i : ι) => Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Ioi.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (iInf.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
-Case conversion may be inaccurate. Consider using '#align Union_Ici_eq_Ioi_infi iUnion_Ici_eq_Ioi_iInfₓ'. -/
 theorem iUnion_Ici_eq_Ioi_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (no_least_elem : (⨅ i, f i) ∉ range f) : (⋃ i : ι, Ici (f i)) = Ioi (⨅ i, f i) := by
   simp only [← IsGLB.biUnion_Ici_eq_Ioi (@isGLB_iInf _ _ _ f) no_least_elem, mem_range,
     Union_exists, Union_Union_eq']
 #align Union_Ici_eq_Ioi_infi iUnion_Ici_eq_Ioi_iInf
 
-/- warning: Union_Iic_eq_Iio_supr -> iUnion_Iic_eq_Iio_iSup is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Not (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (iSup.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f))) -> (Eq.{succ u2} (Set.{u2} R) (Set.iUnion.{u2, u1} R ι (fun (i : ι) => Set.Iic.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Iio.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (iSup.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
-but is expected to have type
-  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Not (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (iSup.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f))) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, u2} R ι (fun (i : ι) => Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Iio.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (iSup.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
-Case conversion may be inaccurate. Consider using '#align Union_Iic_eq_Iio_supr iUnion_Iic_eq_Iio_iSupₓ'. -/
 theorem iUnion_Iic_eq_Iio_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (no_greatest_elem : (⨆ i, f i) ∉ range f) : (⋃ i : ι, Iic (f i)) = Iio (⨆ i, f i) :=
   @iUnion_Ici_eq_Ioi_iInf ι (OrderDual R) _ f no_greatest_elem
 #align Union_Iic_eq_Iio_supr iUnion_Iic_eq_Iio_iSup
 
-/- warning: Union_Ici_eq_Ici_infi -> iUnion_Ici_eq_Ici_iInf is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (iInf.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f)) -> (Eq.{succ u2} (Set.{u2} R) (Set.iUnion.{u2, u1} R ι (fun (i : ι) => Set.Ici.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Ici.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (iInf.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
-but is expected to have type
-  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (iInf.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, u2} R ι (fun (i : ι) => Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (iInf.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
-Case conversion may be inaccurate. Consider using '#align Union_Ici_eq_Ici_infi iUnion_Ici_eq_Ici_iInfₓ'. -/
 theorem iUnion_Ici_eq_Ici_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (has_least_elem : (⨅ i, f i) ∈ range f) : (⋃ i : ι, Ici (f i)) = Ici (⨅ i, f i) := by
   simp only [← IsGLB.biUnion_Ici_eq_Ici (@isGLB_iInf _ _ _ f) has_least_elem, mem_range,
     Union_exists, Union_Union_eq']
 #align Union_Ici_eq_Ici_infi iUnion_Ici_eq_Ici_iInf
 
-/- warning: Union_Iic_eq_Iic_supr -> iUnion_Iic_eq_Iic_iSup is a dubious translation:
-lean 3 declaration is
-  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (iSup.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f)) -> (Eq.{succ u2} (Set.{u2} R) (Set.iUnion.{u2, u1} R ι (fun (i : ι) => Set.Iic.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Iic.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (iSup.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
-but is expected to have type
-  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (iSup.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, u2} R ι (fun (i : ι) => Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (iSup.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
-Case conversion may be inaccurate. Consider using '#align Union_Iic_eq_Iic_supr iUnion_Iic_eq_Iic_iSupₓ'. -/
 theorem iUnion_Iic_eq_Iic_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (has_greatest_elem : (⨆ i, f i) ∈ range f) : (⋃ i : ι, Iic (f i)) = Iic (⨆ i, f i) :=
   @iUnion_Ici_eq_Ici_iInf ι (OrderDual R) _ f has_greatest_elem

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

@@ -38,7 +38,7 @@ variable [Preorder α] {a b c : α}
 
 /- warning: set.Iic_disjoint_Ioi -> Set.Iic_disjoint_Ioi is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Iic.{u1} α _inst_1 a) (Set.Ioi.{u1} α _inst_1 b))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Iic.{u1} α _inst_1 a) (Set.Ioi.{u1} α _inst_1 b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{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 a) (Set.Ioi.{u1} α _inst_1 b))
 Case conversion may be inaccurate. Consider using '#align set.Iic_disjoint_Ioi Set.Iic_disjoint_Ioiₓ'. -/
@@ -49,7 +49,7 @@ theorem Iic_disjoint_Ioi (h : a ≤ b) : Disjoint (Iic a) (Ioi b) :=
 
 /- warning: set.Iic_disjoint_Ioc -> Set.Iic_disjoint_Ioc is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {c : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Iic.{u1} α _inst_1 a) (Set.Ioc.{u1} α _inst_1 b c))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {c : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Iic.{u1} α _inst_1 a) (Set.Ioc.{u1} α _inst_1 b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {c : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{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 a) (Set.Ioc.{u1} α _inst_1 b c))
 Case conversion may be inaccurate. Consider using '#align set.Iic_disjoint_Ioc Set.Iic_disjoint_Iocₓ'. -/
@@ -82,7 +82,7 @@ theorem Ico_disjoint_Ico_same {a b c : α} : Disjoint (Ico a b) (Ico b c) :=
 
 /- warning: set.Ici_disjoint_Iic -> Set.Ici_disjoint_Iic is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ici.{u1} α _inst_1 a) (Set.Iic.{u1} α _inst_1 b)) (Not (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ici.{u1} α _inst_1 a) (Set.Iic.{u1} α _inst_1 b)) (Not (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{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 a) (Set.Iic.{u1} α _inst_1 b)) (Not (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b))
 Case conversion may be inaccurate. Consider using '#align set.Ici_disjoint_Iic Set.Ici_disjoint_Iicₓ'. -/
@@ -93,7 +93,7 @@ theorem Ici_disjoint_Iic : Disjoint (Ici a) (Iic b) ↔ ¬a ≤ b := by
 
 /- warning: set.Iic_disjoint_Ici -> Set.Iic_disjoint_Ici is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Iic.{u1} α _inst_1 a) (Set.Ici.{u1} α _inst_1 b)) (Not (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Iic.{u1} α _inst_1 a) (Set.Ici.{u1} α _inst_1 b)) (Not (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, Iff (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{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 a) (Set.Ici.{u1} α _inst_1 b)) (Not (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a))
 Case conversion may be inaccurate. Consider using '#align set.Iic_disjoint_Ici Set.Iic_disjoint_Iciₓ'. -/
@@ -144,47 +144,71 @@ theorem iUnion_Ico_left (b : α) : (⋃ a, Ico a b) = Iio b := by
 #align set.Union_Ico_left Set.iUnion_Ico_left
 -/
 
-#print Set.iUnion_Iio /-
+/- warning: set.Union_Iio -> Set.iUnion_Iio is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Iio.{u1} α _inst_1 a)) (Set.univ.{u1} α)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Iio.{u1} α _inst_1 a)) (Set.univ.{u1} α)
+Case conversion may be inaccurate. Consider using '#align set.Union_Iio Set.iUnion_Iioₓ'. -/
 @[simp]
 theorem iUnion_Iio [NoMaxOrder α] : (⋃ a : α, Iio a) = univ :=
   iUnion_eq_univ_iff.2 exists_gt
 #align set.Union_Iio Set.iUnion_Iio
--/
 
-#print Set.iUnion_Ioi /-
+/- warning: set.Union_Ioi -> Set.iUnion_Ioi is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioi.{u1} α _inst_1 a)) (Set.univ.{u1} α)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioi.{u1} α _inst_1 a)) (Set.univ.{u1} α)
+Case conversion may be inaccurate. Consider using '#align set.Union_Ioi Set.iUnion_Ioiₓ'. -/
 @[simp]
 theorem iUnion_Ioi [NoMinOrder α] : (⋃ a : α, Ioi a) = univ :=
   iUnion_eq_univ_iff.2 exists_lt
 #align set.Union_Ioi Set.iUnion_Ioi
--/
 
-#print Set.iUnion_Ico_right /-
+/- warning: set.Union_Ico_right -> Set.iUnion_Ico_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.Ico.{u1} α _inst_1 a b)) (Set.Ici.{u1} α _inst_1 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.Ico.{u1} α _inst_1 a b)) (Set.Ici.{u1} α _inst_1 a)
+Case conversion may be inaccurate. Consider using '#align set.Union_Ico_right Set.iUnion_Ico_rightₓ'. -/
 @[simp]
 theorem iUnion_Ico_right [NoMaxOrder α] (a : α) : (⋃ b, Ico a b) = Ici a := by
   simp only [← Ici_inter_Iio, ← inter_Union, Union_Iio, inter_univ]
 #align set.Union_Ico_right Set.iUnion_Ico_right
--/
 
-#print Set.iUnion_Ioo_right /-
+/- warning: set.Union_Ioo_right -> Set.iUnion_Ioo_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.Ioo.{u1} α _inst_1 a b)) (Set.Ioi.{u1} α _inst_1 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (b : α) => Set.Ioo.{u1} α _inst_1 a b)) (Set.Ioi.{u1} α _inst_1 a)
+Case conversion may be inaccurate. Consider using '#align set.Union_Ioo_right Set.iUnion_Ioo_rightₓ'. -/
 @[simp]
 theorem iUnion_Ioo_right [NoMaxOrder α] (a : α) : (⋃ b, Ioo a b) = Ioi a := by
   simp only [← Ioi_inter_Iio, ← inter_Union, Union_Iio, inter_univ]
 #align set.Union_Ioo_right Set.iUnion_Ioo_right
--/
 
-#print Set.iUnion_Ioc_left /-
+/- warning: set.Union_Ioc_left -> Set.iUnion_Ioc_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (b : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioc.{u1} α _inst_1 a b)) (Set.Iic.{u1} α _inst_1 b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (b : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioc.{u1} α _inst_1 a b)) (Set.Iic.{u1} α _inst_1 b)
+Case conversion may be inaccurate. Consider using '#align set.Union_Ioc_left Set.iUnion_Ioc_leftₓ'. -/
 @[simp]
 theorem iUnion_Ioc_left [NoMinOrder α] (b : α) : (⋃ a, Ioc a b) = Iic b := by
   simp only [← Ioi_inter_Iic, ← Union_inter, Union_Ioi, univ_inter]
 #align set.Union_Ioc_left Set.iUnion_Ioc_left
--/
 
-#print Set.iUnion_Ioo_left /-
+/- warning: set.Union_Ioo_left -> Set.iUnion_Ioo_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (b : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioo.{u1} α _inst_1 a b)) (Set.Iio.{u1} α _inst_1 b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (b : α), Eq.{succ u1} (Set.{u1} α) (Set.iUnion.{u1, succ u1} α α (fun (a : α) => Set.Ioo.{u1} α _inst_1 a b)) (Set.Iio.{u1} α _inst_1 b)
+Case conversion may be inaccurate. Consider using '#align set.Union_Ioo_left Set.iUnion_Ioo_leftₓ'. -/
 @[simp]
 theorem iUnion_Ioo_left [NoMinOrder α] (b : α) : (⋃ a, Ioo a b) = Iio b := by
   simp only [← Ioi_inter_Iio, ← Union_inter, Union_Ioi, univ_inter]
 #align set.Union_Ioo_left Set.iUnion_Ioo_left
--/
 
 end Preorder
 
@@ -194,7 +218,7 @@ variable [LinearOrder α] {a₁ a₂ b₁ b₂ : α}
 
 /- warning: set.Ico_disjoint_Ico -> Set.Ico_disjoint_Ico is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a₁ a₂) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b₁ b₂)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a₂ b₂) (LinearOrder.max.{u1} α _inst_1 a₁ b₁))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a₁ a₂) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b₁ b₂)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a₂ b₂) (LinearOrder.max.{u1} α _inst_1 a₁ b₁))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) a₁ a₂) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) b₁ b₂)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a₂ b₂) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a₁ b₁))
 Case conversion may be inaccurate. Consider using '#align set.Ico_disjoint_Ico Set.Ico_disjoint_Icoₓ'. -/
@@ -206,7 +230,7 @@ theorem Ico_disjoint_Ico : Disjoint (Ico a₁ a₂) (Ico b₁ b₂) ↔ min a₂
 
 /- warning: set.Ioc_disjoint_Ioc -> Set.Ioc_disjoint_Ioc is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a₁ a₂) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b₁ b₂)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a₂ b₂) (LinearOrder.max.{u1} α _inst_1 a₁ b₁))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a₁ a₂) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b₁ b₂)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a₂ b₂) (LinearOrder.max.{u1} α _inst_1 a₁ b₁))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) a₁ a₂) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) b₁ b₂)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a₂ b₂) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a₁ b₁))
 Case conversion may be inaccurate. Consider using '#align set.Ioc_disjoint_Ioc Set.Ioc_disjoint_Iocₓ'. -/
@@ -219,7 +243,7 @@ theorem Ioc_disjoint_Ioc : Disjoint (Ioc a₁ a₂) (Ioc b₁ b₂) ↔ min a₂
 
 /- warning: set.eq_of_Ico_disjoint -> Set.eq_of_Ico_disjoint is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x₁ : α} {x₂ : α} {y₁ : α} {y₂ : α}, (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) x₁ x₂) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) y₁ y₂)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) x₁ x₂) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x₂ (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) y₁ y₂)) -> (Eq.{succ u1} α y₁ x₂)
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x₁ : α} {x₂ : α} {y₁ : α} {y₂ : α}, (Disjoint.{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} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) x₁ x₂) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) y₁ y₂)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) x₁ x₂) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x₂ (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) y₁ y₂)) -> (Eq.{succ u1} α y₁ x₂)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x₁ : α} {x₂ : α} {y₁ : α} {y₂ : α}, (Disjoint.{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} α)))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (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} α)))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) x₁ x₂) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) y₁ y₂)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x₁ x₂) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x₂ (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) y₁ y₂)) -> (Eq.{succ u1} α y₁ x₂)
 Case conversion may be inaccurate. Consider using '#align set.eq_of_Ico_disjoint Set.eq_of_Ico_disjointₓ'. -/
@@ -233,37 +257,53 @@ theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x
   exact h.elim (fun h => absurd hx (not_lt_of_le h)) id
 #align set.eq_of_Ico_disjoint Set.eq_of_Ico_disjoint
 
-#print Set.iUnion_Ico_eq_Iio_self_iff /-
+/- warning: set.Union_Ico_eq_Iio_self_iff -> Set.iUnion_Ico_eq_Iio_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {f : ι -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) (f i) a)) (Set.Iio.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) x a) -> (Exists.{u1} ι (fun (i : ι) => LE.le.{u2} α (Preorder.toHasLe.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) (f i) x)))
+but is expected to have type
+  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {f : ι -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) (f i) a)) (Set.Iio.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) x a) -> (Exists.{u1} ι (fun (i : ι) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) (f i) x)))
+Case conversion may be inaccurate. Consider using '#align set.Union_Ico_eq_Iio_self_iff Set.iUnion_Ico_eq_Iio_self_iffₓ'. -/
 @[simp]
 theorem iUnion_Ico_eq_Iio_self_iff {f : ι → α} {a : α} :
     (⋃ i, Ico (f i) a) = Iio a ↔ ∀ x < a, ∃ i, f i ≤ x := by
   simp [← Ici_inter_Iio, ← Union_inter, subset_def]
 #align set.Union_Ico_eq_Iio_self_iff Set.iUnion_Ico_eq_Iio_self_iff
--/
 
-#print Set.iUnion_Ioc_eq_Ioi_self_iff /-
+/- warning: set.Union_Ioc_eq_Ioi_self_iff -> Set.iUnion_Ioc_eq_Ioi_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {f : ι -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a (f i))) (Set.Ioi.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) a x) -> (Exists.{u1} ι (fun (i : ι) => LE.le.{u2} α (Preorder.toHasLe.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) x (f i))))
+but is expected to have type
+  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {f : ι -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a (f i))) (Set.Ioi.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) a x) -> (Exists.{u1} ι (fun (i : ι) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) x (f i))))
+Case conversion may be inaccurate. Consider using '#align set.Union_Ioc_eq_Ioi_self_iff Set.iUnion_Ioc_eq_Ioi_self_iffₓ'. -/
 @[simp]
 theorem iUnion_Ioc_eq_Ioi_self_iff {f : ι → α} {a : α} :
     (⋃ i, Ioc a (f i)) = Ioi a ↔ ∀ x, a < x → ∃ i, x ≤ f i := by
   simp [← Ioi_inter_Iic, ← inter_Union, subset_def]
 #align set.Union_Ioc_eq_Ioi_self_iff Set.iUnion_Ioc_eq_Ioi_self_iff
--/
 
-#print Set.biUnion_Ico_eq_Iio_self_iff /-
+/- warning: set.bUnion_Ico_eq_Iio_self_iff -> Set.biUnion_Ico_eq_Iio_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {p : ι -> Prop} {f : forall (i : ι), (p i) -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (p i) (fun (hi : p i) => Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) (f i hi) a))) (Set.Iio.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) x a) -> (Exists.{u1} ι (fun (i : ι) => Exists.{0} (p i) (fun (hi : p i) => LE.le.{u2} α (Preorder.toHasLe.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) (f i hi) x))))
+but is expected to have type
+  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {p : ι -> Prop} {f : forall (i : ι), (p i) -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (p i) (fun (hi : p i) => Set.Ico.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) (f i hi) a))) (Set.Iio.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) x a) -> (Exists.{u1} ι (fun (i : ι) => Exists.{0} (p i) (fun (hi : p i) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) (f i hi) x))))
+Case conversion may be inaccurate. Consider using '#align set.bUnion_Ico_eq_Iio_self_iff Set.biUnion_Ico_eq_Iio_self_iffₓ'. -/
 @[simp]
 theorem biUnion_Ico_eq_Iio_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
     (⋃ (i) (hi : p i), Ico (f i hi) a) = Iio a ↔ ∀ x < a, ∃ i hi, f i hi ≤ x := by
   simp [← Ici_inter_Iio, ← Union_inter, subset_def]
 #align set.bUnion_Ico_eq_Iio_self_iff Set.biUnion_Ico_eq_Iio_self_iff
--/
 
-#print Set.biUnion_Ioc_eq_Ioi_self_iff /-
+/- warning: set.bUnion_Ioc_eq_Ioi_self_iff -> Set.biUnion_Ioc_eq_Ioi_self_iff is a dubious translation:
+lean 3 declaration is
+  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {p : ι -> Prop} {f : forall (i : ι), (p i) -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (p i) (fun (hi : p i) => Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a (f i hi)))) (Set.Ioi.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1)))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toHasLt.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) a x) -> (Exists.{u1} ι (fun (i : ι) => Exists.{0} (p i) (fun (hi : p i) => LE.le.{u2} α (Preorder.toHasLe.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (LinearOrder.toLattice.{u2} α _inst_1))))) x (f i hi)))))
+but is expected to have type
+  forall {ι : Sort.{u1}} {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {p : ι -> Prop} {f : forall (i : ι), (p i) -> α} {a : α}, Iff (Eq.{succ u2} (Set.{u2} α) (Set.iUnion.{u2, u1} α ι (fun (i : ι) => Set.iUnion.{u2, 0} α (p i) (fun (hi : p i) => Set.Ioc.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a (f i hi)))) (Set.Ioi.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) a)) (forall (x : α), (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) a x) -> (Exists.{u1} ι (fun (i : ι) => Exists.{0} (p i) (fun (hi : p i) => LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)))))) x (f i hi)))))
+Case conversion may be inaccurate. Consider using '#align set.bUnion_Ioc_eq_Ioi_self_iff Set.biUnion_Ioc_eq_Ioi_self_iffₓ'. -/
 @[simp]
 theorem biUnion_Ioc_eq_Ioi_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
     (⋃ (i) (hi : p i), Ioc a (f i hi)) = Ioi a ↔ ∀ x, a < x → ∃ i hi, x ≤ f i hi := by
   simp [← Ioi_inter_Iic, ← inter_Union, subset_def]
 #align set.bUnion_Ioc_eq_Ioi_self_iff Set.biUnion_Ioc_eq_Ioi_self_iff
--/
 
 end LinearOrder
 

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

@@ -102,88 +102,88 @@ theorem Iic_disjoint_Ici : Disjoint (Iic a) (Ici b) ↔ ¬b ≤ a :=
   disjoint_comm.trans Ici_disjoint_Iic
 #align set.Iic_disjoint_Ici Set.Iic_disjoint_Ici
 
-#print Set.unionᵢ_Iic /-
+#print Set.iUnion_Iic /-
 @[simp]
-theorem unionᵢ_Iic : (⋃ a : α, Iic a) = univ :=
-  unionᵢ_eq_univ_iff.2 fun x => ⟨x, right_mem_Iic⟩
-#align set.Union_Iic Set.unionᵢ_Iic
+theorem iUnion_Iic : (⋃ a : α, Iic a) = univ :=
+  iUnion_eq_univ_iff.2 fun x => ⟨x, right_mem_Iic⟩
+#align set.Union_Iic Set.iUnion_Iic
 -/
 
-#print Set.unionᵢ_Ici /-
+#print Set.iUnion_Ici /-
 @[simp]
-theorem unionᵢ_Ici : (⋃ a : α, Ici a) = univ :=
-  unionᵢ_eq_univ_iff.2 fun x => ⟨x, left_mem_Ici⟩
-#align set.Union_Ici Set.unionᵢ_Ici
+theorem iUnion_Ici : (⋃ a : α, Ici a) = univ :=
+  iUnion_eq_univ_iff.2 fun x => ⟨x, left_mem_Ici⟩
+#align set.Union_Ici Set.iUnion_Ici
 -/
 
-#print Set.unionᵢ_Icc_right /-
+#print Set.iUnion_Icc_right /-
 @[simp]
-theorem unionᵢ_Icc_right (a : α) : (⋃ b, Icc a b) = Ici a := by
+theorem iUnion_Icc_right (a : α) : (⋃ b, Icc a b) = Ici a := by
   simp only [← Ici_inter_Iic, ← inter_Union, Union_Iic, inter_univ]
-#align set.Union_Icc_right Set.unionᵢ_Icc_right
+#align set.Union_Icc_right Set.iUnion_Icc_right
 -/
 
-#print Set.unionᵢ_Ioc_right /-
+#print Set.iUnion_Ioc_right /-
 @[simp]
-theorem unionᵢ_Ioc_right (a : α) : (⋃ b, Ioc a b) = Ioi a := by
+theorem iUnion_Ioc_right (a : α) : (⋃ b, Ioc a b) = Ioi a := by
   simp only [← Ioi_inter_Iic, ← inter_Union, Union_Iic, inter_univ]
-#align set.Union_Ioc_right Set.unionᵢ_Ioc_right
+#align set.Union_Ioc_right Set.iUnion_Ioc_right
 -/
 
-#print Set.unionᵢ_Icc_left /-
+#print Set.iUnion_Icc_left /-
 @[simp]
-theorem unionᵢ_Icc_left (b : α) : (⋃ a, Icc a b) = Iic b := by
+theorem iUnion_Icc_left (b : α) : (⋃ a, Icc a b) = Iic b := by
   simp only [← Ici_inter_Iic, ← Union_inter, Union_Ici, univ_inter]
-#align set.Union_Icc_left Set.unionᵢ_Icc_left
+#align set.Union_Icc_left Set.iUnion_Icc_left
 -/
 
-#print Set.unionᵢ_Ico_left /-
+#print Set.iUnion_Ico_left /-
 @[simp]
-theorem unionᵢ_Ico_left (b : α) : (⋃ a, Ico a b) = Iio b := by
+theorem iUnion_Ico_left (b : α) : (⋃ a, Ico a b) = Iio b := by
   simp only [← Ici_inter_Iio, ← Union_inter, Union_Ici, univ_inter]
-#align set.Union_Ico_left Set.unionᵢ_Ico_left
+#align set.Union_Ico_left Set.iUnion_Ico_left
 -/
 
-#print Set.unionᵢ_Iio /-
+#print Set.iUnion_Iio /-
 @[simp]
-theorem unionᵢ_Iio [NoMaxOrder α] : (⋃ a : α, Iio a) = univ :=
-  unionᵢ_eq_univ_iff.2 exists_gt
-#align set.Union_Iio Set.unionᵢ_Iio
+theorem iUnion_Iio [NoMaxOrder α] : (⋃ a : α, Iio a) = univ :=
+  iUnion_eq_univ_iff.2 exists_gt
+#align set.Union_Iio Set.iUnion_Iio
 -/
 
-#print Set.unionᵢ_Ioi /-
+#print Set.iUnion_Ioi /-
 @[simp]
-theorem unionᵢ_Ioi [NoMinOrder α] : (⋃ a : α, Ioi a) = univ :=
-  unionᵢ_eq_univ_iff.2 exists_lt
-#align set.Union_Ioi Set.unionᵢ_Ioi
+theorem iUnion_Ioi [NoMinOrder α] : (⋃ a : α, Ioi a) = univ :=
+  iUnion_eq_univ_iff.2 exists_lt
+#align set.Union_Ioi Set.iUnion_Ioi
 -/
 
-#print Set.unionᵢ_Ico_right /-
+#print Set.iUnion_Ico_right /-
 @[simp]
-theorem unionᵢ_Ico_right [NoMaxOrder α] (a : α) : (⋃ b, Ico a b) = Ici a := by
+theorem iUnion_Ico_right [NoMaxOrder α] (a : α) : (⋃ b, Ico a b) = Ici a := by
   simp only [← Ici_inter_Iio, ← inter_Union, Union_Iio, inter_univ]
-#align set.Union_Ico_right Set.unionᵢ_Ico_right
+#align set.Union_Ico_right Set.iUnion_Ico_right
 -/
 
-#print Set.unionᵢ_Ioo_right /-
+#print Set.iUnion_Ioo_right /-
 @[simp]
-theorem unionᵢ_Ioo_right [NoMaxOrder α] (a : α) : (⋃ b, Ioo a b) = Ioi a := by
+theorem iUnion_Ioo_right [NoMaxOrder α] (a : α) : (⋃ b, Ioo a b) = Ioi a := by
   simp only [← Ioi_inter_Iio, ← inter_Union, Union_Iio, inter_univ]
-#align set.Union_Ioo_right Set.unionᵢ_Ioo_right
+#align set.Union_Ioo_right Set.iUnion_Ioo_right
 -/
 
-#print Set.unionᵢ_Ioc_left /-
+#print Set.iUnion_Ioc_left /-
 @[simp]
-theorem unionᵢ_Ioc_left [NoMinOrder α] (b : α) : (⋃ a, Ioc a b) = Iic b := by
+theorem iUnion_Ioc_left [NoMinOrder α] (b : α) : (⋃ a, Ioc a b) = Iic b := by
   simp only [← Ioi_inter_Iic, ← Union_inter, Union_Ioi, univ_inter]
-#align set.Union_Ioc_left Set.unionᵢ_Ioc_left
+#align set.Union_Ioc_left Set.iUnion_Ioc_left
 -/
 
-#print Set.unionᵢ_Ioo_left /-
+#print Set.iUnion_Ioo_left /-
 @[simp]
-theorem unionᵢ_Ioo_left [NoMinOrder α] (b : α) : (⋃ a, Ioo a b) = Iio b := by
+theorem iUnion_Ioo_left [NoMinOrder α] (b : α) : (⋃ a, Ioo a b) = Iio b := by
   simp only [← Ioi_inter_Iio, ← Union_inter, Union_Ioi, univ_inter]
-#align set.Union_Ioo_left Set.unionᵢ_Ioo_left
+#align set.Union_Ioo_left Set.iUnion_Ioo_left
 -/
 
 end Preorder
@@ -233,36 +233,36 @@ theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x
   exact h.elim (fun h => absurd hx (not_lt_of_le h)) id
 #align set.eq_of_Ico_disjoint Set.eq_of_Ico_disjoint
 
-#print Set.unionᵢ_Ico_eq_Iio_self_iff /-
+#print Set.iUnion_Ico_eq_Iio_self_iff /-
 @[simp]
-theorem unionᵢ_Ico_eq_Iio_self_iff {f : ι → α} {a : α} :
+theorem iUnion_Ico_eq_Iio_self_iff {f : ι → α} {a : α} :
     (⋃ i, Ico (f i) a) = Iio a ↔ ∀ x < a, ∃ i, f i ≤ x := by
   simp [← Ici_inter_Iio, ← Union_inter, subset_def]
-#align set.Union_Ico_eq_Iio_self_iff Set.unionᵢ_Ico_eq_Iio_self_iff
+#align set.Union_Ico_eq_Iio_self_iff Set.iUnion_Ico_eq_Iio_self_iff
 -/
 
-#print Set.unionᵢ_Ioc_eq_Ioi_self_iff /-
+#print Set.iUnion_Ioc_eq_Ioi_self_iff /-
 @[simp]
-theorem unionᵢ_Ioc_eq_Ioi_self_iff {f : ι → α} {a : α} :
+theorem iUnion_Ioc_eq_Ioi_self_iff {f : ι → α} {a : α} :
     (⋃ i, Ioc a (f i)) = Ioi a ↔ ∀ x, a < x → ∃ i, x ≤ f i := by
   simp [← Ioi_inter_Iic, ← inter_Union, subset_def]
-#align set.Union_Ioc_eq_Ioi_self_iff Set.unionᵢ_Ioc_eq_Ioi_self_iff
+#align set.Union_Ioc_eq_Ioi_self_iff Set.iUnion_Ioc_eq_Ioi_self_iff
 -/
 
-#print Set.bunionᵢ_Ico_eq_Iio_self_iff /-
+#print Set.biUnion_Ico_eq_Iio_self_iff /-
 @[simp]
-theorem bunionᵢ_Ico_eq_Iio_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
+theorem biUnion_Ico_eq_Iio_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
     (⋃ (i) (hi : p i), Ico (f i hi) a) = Iio a ↔ ∀ x < a, ∃ i hi, f i hi ≤ x := by
   simp [← Ici_inter_Iio, ← Union_inter, subset_def]
-#align set.bUnion_Ico_eq_Iio_self_iff Set.bunionᵢ_Ico_eq_Iio_self_iff
+#align set.bUnion_Ico_eq_Iio_self_iff Set.biUnion_Ico_eq_Iio_self_iff
 -/
 
-#print Set.bunionᵢ_Ioc_eq_Ioi_self_iff /-
+#print Set.biUnion_Ioc_eq_Ioi_self_iff /-
 @[simp]
-theorem bunionᵢ_Ioc_eq_Ioi_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
+theorem biUnion_Ioc_eq_Ioi_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
     (⋃ (i) (hi : p i), Ioc a (f i hi)) = Ioi a ↔ ∀ x, a < x → ∃ i hi, x ≤ f i hi := by
   simp [← Ioi_inter_Iic, ← inter_Union, subset_def]
-#align set.bUnion_Ioc_eq_Ioi_self_iff Set.bunionᵢ_Ioc_eq_Ioi_self_iff
+#align set.bUnion_Ioc_eq_Ioi_self_iff Set.biUnion_Ioc_eq_Ioi_self_iff
 -/
 
 end LinearOrder
@@ -273,36 +273,36 @@ section UnionIxx
 
 variable [LinearOrder α] {s : Set α} {a : α} {f : ι → α}
 
-#print IsGLB.bunionᵢ_Ioi_eq /-
-theorem IsGLB.bunionᵢ_Ioi_eq (h : IsGLB s a) : (⋃ x ∈ s, Ioi x) = Ioi a :=
+#print IsGLB.biUnion_Ioi_eq /-
+theorem IsGLB.biUnion_Ioi_eq (h : IsGLB s a) : (⋃ x ∈ s, Ioi x) = Ioi a :=
   by
   refine' (Union₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ioi_subset_Ioi (h.1 hx)
   · rcases h.exists_between hx with ⟨y, hys, hay, hyx⟩
     exact mem_bUnion hys hyx
-#align is_glb.bUnion_Ioi_eq IsGLB.bunionᵢ_Ioi_eq
+#align is_glb.bUnion_Ioi_eq IsGLB.biUnion_Ioi_eq
 -/
 
-#print IsGLB.unionᵢ_Ioi_eq /-
-theorem IsGLB.unionᵢ_Ioi_eq (h : IsGLB (range f) a) : (⋃ x, Ioi (f x)) = Ioi a :=
-  bunionᵢ_range.symm.trans h.bunionᵢ_Ioi_eq
-#align is_glb.Union_Ioi_eq IsGLB.unionᵢ_Ioi_eq
+#print IsGLB.iUnion_Ioi_eq /-
+theorem IsGLB.iUnion_Ioi_eq (h : IsGLB (range f) a) : (⋃ x, Ioi (f x)) = Ioi a :=
+  biUnion_range.symm.trans h.biUnion_Ioi_eq
+#align is_glb.Union_Ioi_eq IsGLB.iUnion_Ioi_eq
 -/
 
-#print IsLUB.bunionᵢ_Iio_eq /-
-theorem IsLUB.bunionᵢ_Iio_eq (h : IsLUB s a) : (⋃ x ∈ s, Iio x) = Iio a :=
-  h.dual.bunionᵢ_Ioi_eq
-#align is_lub.bUnion_Iio_eq IsLUB.bunionᵢ_Iio_eq
+#print IsLUB.biUnion_Iio_eq /-
+theorem IsLUB.biUnion_Iio_eq (h : IsLUB s a) : (⋃ x ∈ s, Iio x) = Iio a :=
+  h.dual.biUnion_Ioi_eq
+#align is_lub.bUnion_Iio_eq IsLUB.biUnion_Iio_eq
 -/
 
-#print IsLUB.unionᵢ_Iio_eq /-
-theorem IsLUB.unionᵢ_Iio_eq (h : IsLUB (range f) a) : (⋃ x, Iio (f x)) = Iio a :=
-  h.dual.unionᵢ_Ioi_eq
-#align is_lub.Union_Iio_eq IsLUB.unionᵢ_Iio_eq
+#print IsLUB.iUnion_Iio_eq /-
+theorem IsLUB.iUnion_Iio_eq (h : IsLUB (range f) a) : (⋃ x, Iio (f x)) = Iio a :=
+  h.dual.iUnion_Ioi_eq
+#align is_lub.Union_Iio_eq IsLUB.iUnion_Iio_eq
 -/
 
-#print IsGLB.bunionᵢ_Ici_eq_Ioi /-
-theorem IsGLB.bunionᵢ_Ici_eq_Ioi (a_glb : IsGLB s a) (a_not_mem : a ∉ s) :
+#print IsGLB.biUnion_Ici_eq_Ioi /-
+theorem IsGLB.biUnion_Ici_eq_Ioi (a_glb : IsGLB s a) (a_not_mem : a ∉ s) :
     (⋃ x ∈ s, Ici x) = Ioi a :=
   by
   refine' (Union₂_subset fun x hx => _).antisymm fun x hx => _
@@ -310,77 +310,77 @@ theorem IsGLB.bunionᵢ_Ici_eq_Ioi (a_glb : IsGLB s a) (a_not_mem : a ∉ s) :
   · rcases a_glb.exists_between hx with ⟨y, hys, hay, hyx⟩
     apply mem_Union₂.mpr
     refine' ⟨y, hys, hyx.le⟩
-#align is_glb.bUnion_Ici_eq_Ioi IsGLB.bunionᵢ_Ici_eq_Ioi
+#align is_glb.bUnion_Ici_eq_Ioi IsGLB.biUnion_Ici_eq_Ioi
 -/
 
-#print IsGLB.bunionᵢ_Ici_eq_Ici /-
-theorem IsGLB.bunionᵢ_Ici_eq_Ici (a_glb : IsGLB s a) (a_mem : a ∈ s) : (⋃ x ∈ s, Ici x) = Ici a :=
+#print IsGLB.biUnion_Ici_eq_Ici /-
+theorem IsGLB.biUnion_Ici_eq_Ici (a_glb : IsGLB s a) (a_mem : a ∈ s) : (⋃ x ∈ s, Ici x) = Ici a :=
   by
   refine' (Union₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ici_subset_Ici.mpr (mem_lower_bounds.mp a_glb.1 x hx)
   · apply mem_Union₂.mpr
     refine' ⟨a, a_mem, hx⟩
-#align is_glb.bUnion_Ici_eq_Ici IsGLB.bunionᵢ_Ici_eq_Ici
+#align is_glb.bUnion_Ici_eq_Ici IsGLB.biUnion_Ici_eq_Ici
 -/
 
-#print IsLUB.bunionᵢ_Iic_eq_Iio /-
-theorem IsLUB.bunionᵢ_Iic_eq_Iio (a_lub : IsLUB s a) (a_not_mem : a ∉ s) :
+#print IsLUB.biUnion_Iic_eq_Iio /-
+theorem IsLUB.biUnion_Iic_eq_Iio (a_lub : IsLUB s a) (a_not_mem : a ∉ s) :
     (⋃ x ∈ s, Iic x) = Iio a :=
-  a_lub.dual.bunionᵢ_Ici_eq_Ioi a_not_mem
-#align is_lub.bUnion_Iic_eq_Iio IsLUB.bunionᵢ_Iic_eq_Iio
+  a_lub.dual.biUnion_Ici_eq_Ioi a_not_mem
+#align is_lub.bUnion_Iic_eq_Iio IsLUB.biUnion_Iic_eq_Iio
 -/
 
-#print IsLUB.bunionᵢ_Iic_eq_Iic /-
-theorem IsLUB.bunionᵢ_Iic_eq_Iic (a_lub : IsLUB s a) (a_mem : a ∈ s) : (⋃ x ∈ s, Iic x) = Iic a :=
-  a_lub.dual.bunionᵢ_Ici_eq_Ici a_mem
-#align is_lub.bUnion_Iic_eq_Iic IsLUB.bunionᵢ_Iic_eq_Iic
+#print IsLUB.biUnion_Iic_eq_Iic /-
+theorem IsLUB.biUnion_Iic_eq_Iic (a_lub : IsLUB s a) (a_mem : a ∈ s) : (⋃ x ∈ s, Iic x) = Iic a :=
+  a_lub.dual.biUnion_Ici_eq_Ici a_mem
+#align is_lub.bUnion_Iic_eq_Iic IsLUB.biUnion_Iic_eq_Iic
 -/
 
-/- warning: Union_Ici_eq_Ioi_infi -> unionᵢ_Ici_eq_Ioi_infᵢ is a dubious translation:
+/- warning: Union_Ici_eq_Ioi_infi -> iUnion_Ici_eq_Ioi_iInf is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Not (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (infᵢ.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f))) -> (Eq.{succ u2} (Set.{u2} R) (Set.unionᵢ.{u2, u1} R ι (fun (i : ι) => Set.Ici.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Ioi.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (infᵢ.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
+  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Not (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (iInf.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f))) -> (Eq.{succ u2} (Set.{u2} R) (Set.iUnion.{u2, u1} R ι (fun (i : ι) => Set.Ici.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Ioi.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (iInf.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
 but is expected to have type
-  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Not (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (infᵢ.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f))) -> (Eq.{succ u1} (Set.{u1} R) (Set.unionᵢ.{u1, u2} R ι (fun (i : ι) => Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Ioi.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (infᵢ.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
-Case conversion may be inaccurate. Consider using '#align Union_Ici_eq_Ioi_infi unionᵢ_Ici_eq_Ioi_infᵢₓ'. -/
-theorem unionᵢ_Ici_eq_Ioi_infᵢ {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Not (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (iInf.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f))) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, u2} R ι (fun (i : ι) => Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Ioi.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (iInf.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
+Case conversion may be inaccurate. Consider using '#align Union_Ici_eq_Ioi_infi iUnion_Ici_eq_Ioi_iInfₓ'. -/
+theorem iUnion_Ici_eq_Ioi_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (no_least_elem : (⨅ i, f i) ∉ range f) : (⋃ i : ι, Ici (f i)) = Ioi (⨅ i, f i) := by
-  simp only [← IsGLB.bunionᵢ_Ici_eq_Ioi (@isGLB_infᵢ _ _ _ f) no_least_elem, mem_range,
+  simp only [← IsGLB.biUnion_Ici_eq_Ioi (@isGLB_iInf _ _ _ f) no_least_elem, mem_range,
     Union_exists, Union_Union_eq']
-#align Union_Ici_eq_Ioi_infi unionᵢ_Ici_eq_Ioi_infᵢ
+#align Union_Ici_eq_Ioi_infi iUnion_Ici_eq_Ioi_iInf
 
-/- warning: Union_Iic_eq_Iio_supr -> unionᵢ_Iic_eq_Iio_supᵢ is a dubious translation:
+/- warning: Union_Iic_eq_Iio_supr -> iUnion_Iic_eq_Iio_iSup is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Not (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (supᵢ.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f))) -> (Eq.{succ u2} (Set.{u2} R) (Set.unionᵢ.{u2, u1} R ι (fun (i : ι) => Set.Iic.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Iio.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (supᵢ.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
+  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Not (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (iSup.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f))) -> (Eq.{succ u2} (Set.{u2} R) (Set.iUnion.{u2, u1} R ι (fun (i : ι) => Set.Iic.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Iio.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (iSup.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
 but is expected to have type
-  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Not (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (supᵢ.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f))) -> (Eq.{succ u1} (Set.{u1} R) (Set.unionᵢ.{u1, u2} R ι (fun (i : ι) => Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Iio.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (supᵢ.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
-Case conversion may be inaccurate. Consider using '#align Union_Iic_eq_Iio_supr unionᵢ_Iic_eq_Iio_supᵢₓ'. -/
-theorem unionᵢ_Iic_eq_Iio_supᵢ {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Not (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (iSup.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f))) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, u2} R ι (fun (i : ι) => Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Iio.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (iSup.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
+Case conversion may be inaccurate. Consider using '#align Union_Iic_eq_Iio_supr iUnion_Iic_eq_Iio_iSupₓ'. -/
+theorem iUnion_Iic_eq_Iio_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (no_greatest_elem : (⨆ i, f i) ∉ range f) : (⋃ i : ι, Iic (f i)) = Iio (⨆ i, f i) :=
-  @unionᵢ_Ici_eq_Ioi_infᵢ ι (OrderDual R) _ f no_greatest_elem
-#align Union_Iic_eq_Iio_supr unionᵢ_Iic_eq_Iio_supᵢ
+  @iUnion_Ici_eq_Ioi_iInf ι (OrderDual R) _ f no_greatest_elem
+#align Union_Iic_eq_Iio_supr iUnion_Iic_eq_Iio_iSup
 
-/- warning: Union_Ici_eq_Ici_infi -> unionᵢ_Ici_eq_Ici_infᵢ is a dubious translation:
+/- warning: Union_Ici_eq_Ici_infi -> iUnion_Ici_eq_Ici_iInf is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (infᵢ.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f)) -> (Eq.{succ u2} (Set.{u2} R) (Set.unionᵢ.{u2, u1} R ι (fun (i : ι) => Set.Ici.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Ici.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (infᵢ.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
+  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (iInf.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f)) -> (Eq.{succ u2} (Set.{u2} R) (Set.iUnion.{u2, u1} R ι (fun (i : ι) => Set.Ici.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Ici.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (iInf.{u2, u1} R (CompleteSemilatticeInf.toHasInf.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
 but is expected to have type
-  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (infᵢ.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f)) -> (Eq.{succ u1} (Set.{u1} R) (Set.unionᵢ.{u1, u2} R ι (fun (i : ι) => Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (infᵢ.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
-Case conversion may be inaccurate. Consider using '#align Union_Ici_eq_Ici_infi unionᵢ_Ici_eq_Ici_infᵢₓ'. -/
-theorem unionᵢ_Ici_eq_Ici_infᵢ {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (iInf.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, u2} R ι (fun (i : ι) => Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Ici.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (iInf.{u1, u2} R (CompleteLattice.toInfSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
+Case conversion may be inaccurate. Consider using '#align Union_Ici_eq_Ici_infi iUnion_Ici_eq_Ici_iInfₓ'. -/
+theorem iUnion_Ici_eq_Ici_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (has_least_elem : (⨅ i, f i) ∈ range f) : (⋃ i : ι, Ici (f i)) = Ici (⨅ i, f i) := by
-  simp only [← IsGLB.bunionᵢ_Ici_eq_Ici (@isGLB_infᵢ _ _ _ f) has_least_elem, mem_range,
+  simp only [← IsGLB.biUnion_Ici_eq_Ici (@isGLB_iInf _ _ _ f) has_least_elem, mem_range,
     Union_exists, Union_Union_eq']
-#align Union_Ici_eq_Ici_infi unionᵢ_Ici_eq_Ici_infᵢ
+#align Union_Ici_eq_Ici_infi iUnion_Ici_eq_Ici_iInf
 
-/- warning: Union_Iic_eq_Iic_supr -> unionᵢ_Iic_eq_Iic_supᵢ is a dubious translation:
+/- warning: Union_Iic_eq_Iic_supr -> iUnion_Iic_eq_Iic_iSup is a dubious translation:
 lean 3 declaration is
-  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (supᵢ.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f)) -> (Eq.{succ u2} (Set.{u2} R) (Set.unionᵢ.{u2, u1} R ι (fun (i : ι) => Set.Iic.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Iic.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (supᵢ.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
+  forall {ι : Sort.{u1}} {R : Type.{u2}} [_inst_2 : CompleteLinearOrder.{u2} R] {f : ι -> R}, (Membership.Mem.{u2, u2} R (Set.{u2} R) (Set.hasMem.{u2} R) (iSup.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i)) (Set.range.{u2, u1} R ι f)) -> (Eq.{succ u2} (Set.{u2} R) (Set.iUnion.{u2, u1} R ι (fun (i : ι) => Set.Iic.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (f i))) (Set.Iic.{u2} R (PartialOrder.toPreorder.{u2} R (CompleteSemilatticeInf.toPartialOrder.{u2} R (CompleteLattice.toCompleteSemilatticeInf.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2)))) (iSup.{u2, u1} R (CompleteSemilatticeSup.toHasSup.{u2} R (CompleteLattice.toCompleteSemilatticeSup.{u2} R (CompleteLinearOrder.toCompleteLattice.{u2} R _inst_2))) ι (fun (i : ι) => f i))))
 but is expected to have type
-  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (supᵢ.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f)) -> (Eq.{succ u1} (Set.{u1} R) (Set.unionᵢ.{u1, u2} R ι (fun (i : ι) => Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (supᵢ.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
-Case conversion may be inaccurate. Consider using '#align Union_Iic_eq_Iic_supr unionᵢ_Iic_eq_Iic_supᵢₓ'. -/
-theorem unionᵢ_Iic_eq_Iic_supᵢ {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+  forall {ι : Sort.{u2}} {R : Type.{u1}} [_inst_2 : CompleteLinearOrder.{u1} R] {f : ι -> R}, (Membership.mem.{u1, u1} R (Set.{u1} R) (Set.instMembershipSet.{u1} R) (iSup.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i)) (Set.range.{u1, u2} R ι f)) -> (Eq.{succ u1} (Set.{u1} R) (Set.iUnion.{u1, u2} R ι (fun (i : ι) => Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (f i))) (Set.Iic.{u1} R (PartialOrder.toPreorder.{u1} R (CompleteSemilatticeInf.toPartialOrder.{u1} R (CompleteLattice.toCompleteSemilatticeInf.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)))) (iSup.{u1, u2} R (CompleteLattice.toSupSet.{u1} R (CompleteLinearOrder.toCompleteLattice.{u1} R _inst_2)) ι (fun (i : ι) => f i))))
+Case conversion may be inaccurate. Consider using '#align Union_Iic_eq_Iic_supr iUnion_Iic_eq_Iic_iSupₓ'. -/
+theorem iUnion_Iic_eq_Iic_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (has_greatest_elem : (⨆ i, f i) ∈ range f) : (⋃ i : ι, Iic (f i)) = Iic (⨆ i, f i) :=
-  @unionᵢ_Ici_eq_Ici_infᵢ ι (OrderDual R) _ f has_greatest_elem
-#align Union_Iic_eq_Iic_supr unionᵢ_Iic_eq_Iic_supᵢ
+  @iUnion_Ici_eq_Ici_iInf ι (OrderDual R) _ f has_greatest_elem
+#align Union_Iic_eq_Iic_supr iUnion_Iic_eq_Iic_iSup
 
 end UnionIxx
 

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

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.

@@ -10,7 +10,7 @@ import Mathlib.Data.Set.Lattice
 /-!
 # Extra lemmas about intervals
 
-This file contains lemmas about intervals that cannot be included into `Data.Set.Intervals.Basic`
+This file contains lemmas about intervals that cannot be included into `Order.Interval.Set.Basic`
 because this would create an `import` cycle. Namely, lemmas in this file can use definitions
 from `Data.Set.Lattice`, including `Disjoint`.
 

• Golf Directed.exists_mem_subset_of_finset_subset_biUnion using induction tactic.
• Golf Set.fintype.
• Reduce abuse of Set α = α → Prop defeq.

@@ -43,12 +43,12 @@ theorem Iio_disjoint_Ici (h : a ≤ b) : Disjoint (Iio a) (Ici b) :=
 
 @[simp]
 theorem Iic_disjoint_Ioc (h : a ≤ b) : Disjoint (Iic a) (Ioc b c) :=
-  (Iic_disjoint_Ioi h).mono le_rfl fun _ => And.left
+  (Iic_disjoint_Ioi h).mono le_rfl Ioc_subset_Ioi_self
 #align set.Iic_disjoint_Ioc Set.Iic_disjoint_Ioc
 
 @[simp]
 theorem Ioc_disjoint_Ioc_same : Disjoint (Ioc a b) (Ioc b c) :=
-  (Iic_disjoint_Ioc (le_refl b)).mono (fun _ => And.right) le_rfl
+  (Iic_disjoint_Ioc le_rfl).mono Ioc_subset_Iic_self le_rfl
 #align set.Ioc_disjoint_Ioc_same Set.Ioc_disjoint_Ioc_same
 
 @[simp]

Without the DenselyOrdered-hypothesis, this is false in general.

Co-authored-by: sven-manthe <147848313+sven-manthe@users.noreply.github.com>

@@ -151,6 +151,12 @@ theorem Ioc_disjoint_Ioc : Disjoint (Ioc a₁ a₂) (Ioc b₁ b₂) ↔ min a₂
   simpa only [dual_Ico] using h
 #align set.Ioc_disjoint_Ioc Set.Ioc_disjoint_Ioc
 
+@[simp]
+theorem Ioo_disjoint_Ioo [DenselyOrdered α] :
+    Disjoint (Set.Ioo a₁ a₂) (Set.Ioo b₁ b₂) ↔ min a₂ b₂ ≤ max a₁ b₁ := by
+  simp_rw [Set.disjoint_iff_inter_eq_empty, Ioo_inter_Ioo, Ioo_eq_empty_iff, inf_eq_min, sup_eq_max,
+    not_lt]
+
 /-- If two half-open intervals are disjoint and the endpoint of one lies in the other,
   then it must be equal to the endpoint of the other. -/
 theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x₂) (Ico y₁ y₂)) (hx : x₁ < x₂)

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

@@ -13,6 +13,8 @@ import Mathlib.Data.Set.Lattice
 This file contains lemmas about intervals that cannot be included into `Data.Set.Intervals.Basic`
 because this would create an `import` cycle. Namely, lemmas in this file can use definitions
 from `Data.Set.Lattice`, including `Disjoint`.
+
+We consider various intersections and unions of half infinite intervals.
 -/
 
 
@@ -256,4 +258,21 @@ theorem iUnion_Iic_eq_Iic_iSup {R : Type*} [CompleteLinearOrder R] {f : ι → R
   @iUnion_Ici_eq_Ici_iInf ι (OrderDual R) _ f has_greatest_elem
 #align Union_Iic_eq_Iic_supr iUnion_Iic_eq_Iic_iSup
 
+theorem iUnion_Iio_eq_univ_iff : ⋃ i, Iio (f i) = univ ↔ (¬ BddAbove (range f)) := by
+  simp [not_bddAbove_iff, Set.eq_univ_iff_forall]
+
+theorem iUnion_Iic_of_not_bddAbove_range (hf : ¬ BddAbove (range f)) : ⋃ i, Iic (f i) = univ := by
+  refine  Set.eq_univ_of_subset ?_ (iUnion_Iio_eq_univ_iff.mpr hf)
+  gcongr
+  exact Iio_subset_Iic_self
+
+theorem iInter_Iic_eq_empty_iff : ⋂ i, Iic (f i) = ∅ ↔ ¬ BddBelow (range f) := by
+  simp [not_bddBelow_iff, Set.eq_empty_iff_forall_not_mem]
+
+theorem iInter_Iio_of_not_bddBelow_range (hf : ¬ BddBelow (range f)) : ⋂ i, Iio (f i) = ∅ := by
+  refine' eq_empty_of_subset_empty _
+  rw [← iInter_Iic_eq_empty_iff.mpr hf]
+  gcongr
+  exact Iio_subset_Iic_self
+
 end UnionIxx

Sometimes, that line can be golfed into the next line. Inspired by a comment of @loefflerd; any decisions are my own.

@@ -214,7 +214,7 @@ theorem IsGLB.biUnion_Ici_eq_Ioi (a_glb : IsGLB s a) (a_not_mem : a ∉ s) :
   refine' (iUnion₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ici_subset_Ioi.mpr (lt_of_le_of_ne (a_glb.1 hx) fun h => (h ▸ a_not_mem) hx)
   · rcases a_glb.exists_between hx with ⟨y, hys, _, hyx⟩
-    apply mem_iUnion₂.mpr
+    rw [mem_iUnion₂]
     exact ⟨y, hys, hyx.le⟩
 #align is_glb.bUnion_Ici_eq_Ioi IsGLB.biUnion_Ici_eq_Ioi
 
@@ -222,8 +222,7 @@ theorem IsGLB.biUnion_Ici_eq_Ici (a_glb : IsGLB s a) (a_mem : a ∈ s) :
     ⋃ x ∈ s, Ici x = Ici a := by
   refine' (iUnion₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ici_subset_Ici.mpr (mem_lowerBounds.mp a_glb.1 x hx)
-  · apply mem_iUnion₂.mpr
-    exact ⟨a, a_mem, hx⟩
+  · exact mem_iUnion₂.mpr ⟨a, a_mem, hx⟩
 #align is_glb.bUnion_Ici_eq_Ici IsGLB.biUnion_Ici_eq_Ici
 
 theorem IsLUB.biUnion_Iic_eq_Iio (a_lub : IsLUB s a) (a_not_mem : a ∉ s) :

I replaced a few "terminal" refine/refine's with exact.

The strategy was very simple-minded: essentially any refine whose following line had smaller indentation got replaced by exact and then I cleaned up the mess.

This PR certainly leaves some further terminal refines, but maybe the current change is beneficial.

@@ -215,7 +215,7 @@ theorem IsGLB.biUnion_Ici_eq_Ioi (a_glb : IsGLB s a) (a_not_mem : a ∉ s) :
   · exact Ici_subset_Ioi.mpr (lt_of_le_of_ne (a_glb.1 hx) fun h => (h ▸ a_not_mem) hx)
   · rcases a_glb.exists_between hx with ⟨y, hys, _, hyx⟩
     apply mem_iUnion₂.mpr
-    refine' ⟨y, hys, hyx.le⟩
+    exact ⟨y, hys, hyx.le⟩
 #align is_glb.bUnion_Ici_eq_Ioi IsGLB.biUnion_Ici_eq_Ioi
 
 theorem IsGLB.biUnion_Ici_eq_Ici (a_glb : IsGLB s a) (a_mem : a ∈ s) :
@@ -223,7 +223,7 @@ theorem IsGLB.biUnion_Ici_eq_Ici (a_glb : IsGLB s a) (a_mem : a ∈ s) :
   refine' (iUnion₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ici_subset_Ici.mpr (mem_lowerBounds.mp a_glb.1 x hx)
   · apply mem_iUnion₂.mpr
-    refine' ⟨a, a_mem, hx⟩
+    exact ⟨a, a_mem, hx⟩
 #align is_glb.bUnion_Ici_eq_Ici IsGLB.biUnion_Ici_eq_Ici
 
 theorem IsLUB.biUnion_Iic_eq_Iio (a_lub : IsLUB s a) (a_not_mem : a ∉ s) :

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

@@ -35,6 +35,10 @@ theorem Iic_disjoint_Ioi (h : a ≤ b) : Disjoint (Iic a) (Ioi b) :=
   disjoint_left.mpr fun _ ha hb => (h.trans_lt hb).not_le ha
 #align set.Iic_disjoint_Ioi Set.Iic_disjoint_Ioi
 
+@[simp]
+theorem Iio_disjoint_Ici (h : a ≤ b) : Disjoint (Iio a) (Ici b) :=
+  disjoint_left.mpr fun _ ha hb => (h.trans_lt' ha).not_le hb
+
 @[simp]
 theorem Iic_disjoint_Ioc (h : a ≤ b) : Disjoint (Iic a) (Ioc b c) :=
   (Iic_disjoint_Ioi h).mono le_rfl fun _ => And.left

Currently, the layercake formula for the Lebesgue integral assumes sigma-finiteness of the measure, while the layercake formula for the Bochner integral (and integrable functions) doesn't. At the cost of a more complicated proof, we remove the sigma-finiteness also from the Lebesgue measure case.

Co-authored-by: Kalle <kalle.kytola@aalto.fi>

@@ -41,12 +41,12 @@ theorem Iic_disjoint_Ioc (h : a ≤ b) : Disjoint (Iic a) (Ioc b c) :=
 #align set.Iic_disjoint_Ioc Set.Iic_disjoint_Ioc
 
 @[simp]
-theorem Ioc_disjoint_Ioc_same {a b c : α} : Disjoint (Ioc a b) (Ioc b c) :=
+theorem Ioc_disjoint_Ioc_same : Disjoint (Ioc a b) (Ioc b c) :=
   (Iic_disjoint_Ioc (le_refl b)).mono (fun _ => And.right) le_rfl
 #align set.Ioc_disjoint_Ioc_same Set.Ioc_disjoint_Ioc_same
 
 @[simp]
-theorem Ico_disjoint_Ico_same {a b c : α} : Disjoint (Ico a b) (Ico b c) :=
+theorem Ico_disjoint_Ico_same : Disjoint (Ico a b) (Ico b c) :=
   disjoint_left.mpr fun _ hab hbc => hab.2.not_le hbc.1
 #align set.Ico_disjoint_Ico_same Set.Ico_disjoint_Ico_same
 
@@ -60,6 +60,13 @@ theorem Iic_disjoint_Ici : Disjoint (Iic a) (Ici b) ↔ ¬b ≤ a :=
   disjoint_comm.trans Ici_disjoint_Iic
 #align set.Iic_disjoint_Ici Set.Iic_disjoint_Ici
 
+@[simp]
+theorem Ioc_disjoint_Ioi (h : b ≤ c) : Disjoint (Ioc a b) (Ioi c) :=
+  disjoint_left.mpr (fun _ hx hy ↦ (hx.2.trans h).not_lt hy)
+
+theorem Ioc_disjoint_Ioi_same : Disjoint (Ioc a b) (Ioi b) :=
+  Ioc_disjoint_Ioi le_rfl
+
 @[simp]
 theorem iUnion_Iic : ⋃ a : α, Iic a = univ :=
   iUnion_eq_univ_iff.2 fun x => ⟨x, right_mem_Iic⟩

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

This has nice performance benefits.

@@ -224,24 +224,24 @@ theorem IsLUB.biUnion_Iic_eq_Iic (a_lub : IsLUB s a) (a_mem : a ∈ s) : ⋃ x 
   a_lub.dual.biUnion_Ici_eq_Ici a_mem
 #align is_lub.bUnion_Iic_eq_Iic IsLUB.biUnion_Iic_eq_Iic
 
-theorem iUnion_Ici_eq_Ioi_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+theorem iUnion_Ici_eq_Ioi_iInf {R : Type*} [CompleteLinearOrder R] {f : ι → R}
     (no_least_elem : ⨅ i, f i ∉ range f) : ⋃ i : ι, Ici (f i) = Ioi (⨅ i, f i) := by
   simp only [← IsGLB.biUnion_Ici_eq_Ioi (@isGLB_iInf _ _ _ f) no_least_elem, mem_range,
     iUnion_exists, iUnion_iUnion_eq']
 #align Union_Ici_eq_Ioi_infi iUnion_Ici_eq_Ioi_iInf
 
-theorem iUnion_Iic_eq_Iio_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+theorem iUnion_Iic_eq_Iio_iSup {R : Type*} [CompleteLinearOrder R] {f : ι → R}
     (no_greatest_elem : (⨆ i, f i) ∉ range f) : ⋃ i : ι, Iic (f i) = Iio (⨆ i, f i) :=
   @iUnion_Ici_eq_Ioi_iInf ι (OrderDual R) _ f no_greatest_elem
 #align Union_Iic_eq_Iio_supr iUnion_Iic_eq_Iio_iSup
 
-theorem iUnion_Ici_eq_Ici_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+theorem iUnion_Ici_eq_Ici_iInf {R : Type*} [CompleteLinearOrder R] {f : ι → R}
     (has_least_elem : (⨅ i, f i) ∈ range f) : ⋃ i : ι, Ici (f i) = Ici (⨅ i, f i) := by
   simp only [← IsGLB.biUnion_Ici_eq_Ici (@isGLB_iInf _ _ _ f) has_least_elem, mem_range,
     iUnion_exists, iUnion_iUnion_eq']
 #align Union_Ici_eq_Ici_infi iUnion_Ici_eq_Ici_iInf
 
-theorem iUnion_Iic_eq_Iic_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+theorem iUnion_Iic_eq_Iic_iSup {R : Type*} [CompleteLinearOrder R] {f : ι → R}
     (has_greatest_elem : (⨆ i, f i) ∈ range f) : ⋃ i : ι, Iic (f i) = Iic (⨆ i, f i) :=
   @iUnion_Ici_eq_Ici_iInf ι (OrderDual R) _ f has_greatest_elem
 #align Union_Iic_eq_Iic_supr iUnion_Iic_eq_Iic_iSup

• depends on: #5966

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

@@ -2,14 +2,11 @@
 Copyright (c) 2019 Floris van Doorn. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Floris van Doorn, Yury Kudryashov
-
-! This file was ported from Lean 3 source module data.set.intervals.disjoint
-! leanprover-community/mathlib commit 207cfac9fcd06138865b5d04f7091e46d9320432
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Lattice
 
+#align_import data.set.intervals.disjoint from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
+
 /-!
 # Extra lemmas about intervals
 

@@ -64,62 +64,62 @@ theorem Iic_disjoint_Ici : Disjoint (Iic a) (Ici b) ↔ ¬b ≤ a :=
 #align set.Iic_disjoint_Ici Set.Iic_disjoint_Ici
 
 @[simp]
-theorem iUnion_Iic : (⋃ a : α, Iic a) = univ :=
+theorem iUnion_Iic : ⋃ a : α, Iic a = univ :=
   iUnion_eq_univ_iff.2 fun x => ⟨x, right_mem_Iic⟩
 #align set.Union_Iic Set.iUnion_Iic
 
 @[simp]
-theorem iUnion_Ici : (⋃ a : α, Ici a) = univ :=
+theorem iUnion_Ici : ⋃ a : α, Ici a = univ :=
   iUnion_eq_univ_iff.2 fun x => ⟨x, left_mem_Ici⟩
 #align set.Union_Ici Set.iUnion_Ici
 
 @[simp]
-theorem iUnion_Icc_right (a : α) : (⋃ b, Icc a b) = Ici a := by
+theorem iUnion_Icc_right (a : α) : ⋃ b, Icc a b = Ici a := by
   simp only [← Ici_inter_Iic, ← inter_iUnion, iUnion_Iic, inter_univ]
 #align set.Union_Icc_right Set.iUnion_Icc_right
 
 @[simp]
-theorem iUnion_Ioc_right (a : α) : (⋃ b, Ioc a b) = Ioi a := by
+theorem iUnion_Ioc_right (a : α) : ⋃ b, Ioc a b = Ioi a := by
   simp only [← Ioi_inter_Iic, ← inter_iUnion, iUnion_Iic, inter_univ]
 #align set.Union_Ioc_right Set.iUnion_Ioc_right
 
 @[simp]
-theorem iUnion_Icc_left (b : α) : (⋃ a, Icc a b) = Iic b := by
+theorem iUnion_Icc_left (b : α) : ⋃ a, Icc a b = Iic b := by
   simp only [← Ici_inter_Iic, ← iUnion_inter, iUnion_Ici, univ_inter]
 #align set.Union_Icc_left Set.iUnion_Icc_left
 
 @[simp]
-theorem iUnion_Ico_left (b : α) : (⋃ a, Ico a b) = Iio b := by
+theorem iUnion_Ico_left (b : α) : ⋃ a, Ico a b = Iio b := by
   simp only [← Ici_inter_Iio, ← iUnion_inter, iUnion_Ici, univ_inter]
 #align set.Union_Ico_left Set.iUnion_Ico_left
 
 @[simp]
-theorem iUnion_Iio [NoMaxOrder α] : (⋃ a : α, Iio a) = univ :=
+theorem iUnion_Iio [NoMaxOrder α] : ⋃ a : α, Iio a = univ :=
   iUnion_eq_univ_iff.2 exists_gt
 #align set.Union_Iio Set.iUnion_Iio
 
 @[simp]
-theorem iUnion_Ioi [NoMinOrder α] : (⋃ a : α, Ioi a) = univ :=
+theorem iUnion_Ioi [NoMinOrder α] : ⋃ a : α, Ioi a = univ :=
   iUnion_eq_univ_iff.2 exists_lt
 #align set.Union_Ioi Set.iUnion_Ioi
 
 @[simp]
-theorem iUnion_Ico_right [NoMaxOrder α] (a : α) : (⋃ b, Ico a b) = Ici a := by
+theorem iUnion_Ico_right [NoMaxOrder α] (a : α) : ⋃ b, Ico a b = Ici a := by
   simp only [← Ici_inter_Iio, ← inter_iUnion, iUnion_Iio, inter_univ]
 #align set.Union_Ico_right Set.iUnion_Ico_right
 
 @[simp]
-theorem iUnion_Ioo_right [NoMaxOrder α] (a : α) : (⋃ b, Ioo a b) = Ioi a := by
+theorem iUnion_Ioo_right [NoMaxOrder α] (a : α) : ⋃ b, Ioo a b = Ioi a := by
   simp only [← Ioi_inter_Iio, ← inter_iUnion, iUnion_Iio, inter_univ]
 #align set.Union_Ioo_right Set.iUnion_Ioo_right
 
 @[simp]
-theorem iUnion_Ioc_left [NoMinOrder α] (b : α) : (⋃ a, Ioc a b) = Iic b := by
+theorem iUnion_Ioc_left [NoMinOrder α] (b : α) : ⋃ a, Ioc a b = Iic b := by
   simp only [← Ioi_inter_Iic, ← iUnion_inter, iUnion_Ioi, univ_inter]
 #align set.Union_Ioc_left Set.iUnion_Ioc_left
 
 @[simp]
-theorem iUnion_Ioo_left [NoMinOrder α] (b : α) : (⋃ a, Ioo a b) = Iio b := by
+theorem iUnion_Ioo_left [NoMinOrder α] (b : α) : ⋃ a, Ioo a b = Iio b := by
   simp only [← Ioi_inter_Iio, ← iUnion_inter, iUnion_Ioi, univ_inter]
 #align set.Union_Ioo_left Set.iUnion_Ioo_left
 
@@ -152,25 +152,25 @@ theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x
 
 @[simp]
 theorem iUnion_Ico_eq_Iio_self_iff {f : ι → α} {a : α} :
-    (⋃ i, Ico (f i) a) = Iio a ↔ ∀ x < a, ∃ i, f i ≤ x := by
+    ⋃ i, Ico (f i) a = Iio a ↔ ∀ x < a, ∃ i, f i ≤ x := by
   simp [← Ici_inter_Iio, ← iUnion_inter, subset_def]
 #align set.Union_Ico_eq_Iio_self_iff Set.iUnion_Ico_eq_Iio_self_iff
 
 @[simp]
 theorem iUnion_Ioc_eq_Ioi_self_iff {f : ι → α} {a : α} :
-    (⋃ i, Ioc a (f i)) = Ioi a ↔ ∀ x, a < x → ∃ i, x ≤ f i := by
+    ⋃ i, Ioc a (f i) = Ioi a ↔ ∀ x, a < x → ∃ i, x ≤ f i := by
   simp [← Ioi_inter_Iic, ← inter_iUnion, subset_def]
 #align set.Union_Ioc_eq_Ioi_self_iff Set.iUnion_Ioc_eq_Ioi_self_iff
 
 @[simp]
 theorem biUnion_Ico_eq_Iio_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
-    (⋃ (i) (hi : p i), Ico (f i hi) a) = Iio a ↔ ∀ x < a, ∃ i hi, f i hi ≤ x := by
+    ⋃ (i) (hi : p i), Ico (f i hi) a = Iio a ↔ ∀ x < a, ∃ i hi, f i hi ≤ x := by
   simp [← Ici_inter_Iio, ← iUnion_inter, subset_def]
 #align set.bUnion_Ico_eq_Iio_self_iff Set.biUnion_Ico_eq_Iio_self_iff
 
 @[simp]
 theorem biUnion_Ioc_eq_Ioi_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
-    (⋃ (i) (hi : p i), Ioc a (f i hi)) = Ioi a ↔ ∀ x, a < x → ∃ i hi, x ≤ f i hi := by
+    ⋃ (i) (hi : p i), Ioc a (f i hi) = Ioi a ↔ ∀ x, a < x → ∃ i hi, x ≤ f i hi := by
   simp [← Ioi_inter_Iic, ← inter_iUnion, subset_def]
 #align set.bUnion_Ioc_eq_Ioi_self_iff Set.biUnion_Ioc_eq_Ioi_self_iff
 
@@ -182,27 +182,27 @@ section UnionIxx
 
 variable [LinearOrder α] {s : Set α} {a : α} {f : ι → α}
 
-theorem IsGLB.biUnion_Ioi_eq (h : IsGLB s a) : (⋃ x ∈ s, Ioi x) = Ioi a := by
+theorem IsGLB.biUnion_Ioi_eq (h : IsGLB s a) : ⋃ x ∈ s, Ioi x = Ioi a := by
   refine' (iUnion₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ioi_subset_Ioi (h.1 hx)
   · rcases h.exists_between hx with ⟨y, hys, _, hyx⟩
     exact mem_biUnion hys hyx
 #align is_glb.bUnion_Ioi_eq IsGLB.biUnion_Ioi_eq
 
-theorem IsGLB.iUnion_Ioi_eq (h : IsGLB (range f) a) : (⋃ x, Ioi (f x)) = Ioi a :=
+theorem IsGLB.iUnion_Ioi_eq (h : IsGLB (range f) a) : ⋃ x, Ioi (f x) = Ioi a :=
   biUnion_range.symm.trans h.biUnion_Ioi_eq
 #align is_glb.Union_Ioi_eq IsGLB.iUnion_Ioi_eq
 
-theorem IsLUB.biUnion_Iio_eq (h : IsLUB s a) : (⋃ x ∈ s, Iio x) = Iio a :=
+theorem IsLUB.biUnion_Iio_eq (h : IsLUB s a) : ⋃ x ∈ s, Iio x = Iio a :=
   h.dual.biUnion_Ioi_eq
 #align is_lub.bUnion_Iio_eq IsLUB.biUnion_Iio_eq
 
-theorem IsLUB.iUnion_Iio_eq (h : IsLUB (range f) a) : (⋃ x, Iio (f x)) = Iio a :=
+theorem IsLUB.iUnion_Iio_eq (h : IsLUB (range f) a) : ⋃ x, Iio (f x) = Iio a :=
   h.dual.iUnion_Ioi_eq
 #align is_lub.Union_Iio_eq IsLUB.iUnion_Iio_eq
 
 theorem IsGLB.biUnion_Ici_eq_Ioi (a_glb : IsGLB s a) (a_not_mem : a ∉ s) :
-    (⋃ x ∈ s, Ici x) = Ioi a := by
+    ⋃ x ∈ s, Ici x = Ioi a := by
   refine' (iUnion₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ici_subset_Ioi.mpr (lt_of_le_of_ne (a_glb.1 hx) fun h => (h ▸ a_not_mem) hx)
   · rcases a_glb.exists_between hx with ⟨y, hys, _, hyx⟩
@@ -211,7 +211,7 @@ theorem IsGLB.biUnion_Ici_eq_Ioi (a_glb : IsGLB s a) (a_not_mem : a ∉ s) :
 #align is_glb.bUnion_Ici_eq_Ioi IsGLB.biUnion_Ici_eq_Ioi
 
 theorem IsGLB.biUnion_Ici_eq_Ici (a_glb : IsGLB s a) (a_mem : a ∈ s) :
-    (⋃ x ∈ s, Ici x) = Ici a := by
+    ⋃ x ∈ s, Ici x = Ici a := by
   refine' (iUnion₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ici_subset_Ici.mpr (mem_lowerBounds.mp a_glb.1 x hx)
   · apply mem_iUnion₂.mpr
@@ -219,33 +219,33 @@ theorem IsGLB.biUnion_Ici_eq_Ici (a_glb : IsGLB s a) (a_mem : a ∈ s) :
 #align is_glb.bUnion_Ici_eq_Ici IsGLB.biUnion_Ici_eq_Ici
 
 theorem IsLUB.biUnion_Iic_eq_Iio (a_lub : IsLUB s a) (a_not_mem : a ∉ s) :
-    (⋃ x ∈ s, Iic x) = Iio a :=
+    ⋃ x ∈ s, Iic x = Iio a :=
   a_lub.dual.biUnion_Ici_eq_Ioi a_not_mem
 #align is_lub.bUnion_Iic_eq_Iio IsLUB.biUnion_Iic_eq_Iio
 
-theorem IsLUB.biUnion_Iic_eq_Iic (a_lub : IsLUB s a) (a_mem : a ∈ s) : (⋃ x ∈ s, Iic x) = Iic a :=
+theorem IsLUB.biUnion_Iic_eq_Iic (a_lub : IsLUB s a) (a_mem : a ∈ s) : ⋃ x ∈ s, Iic x = Iic a :=
   a_lub.dual.biUnion_Ici_eq_Ici a_mem
 #align is_lub.bUnion_Iic_eq_Iic IsLUB.biUnion_Iic_eq_Iic
 
 theorem iUnion_Ici_eq_Ioi_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
-    (no_least_elem : (⨅ i, f i) ∉ range f) : (⋃ i : ι, Ici (f i)) = Ioi (⨅ i, f i) := by
+    (no_least_elem : ⨅ i, f i ∉ range f) : ⋃ i : ι, Ici (f i) = Ioi (⨅ i, f i) := by
   simp only [← IsGLB.biUnion_Ici_eq_Ioi (@isGLB_iInf _ _ _ f) no_least_elem, mem_range,
     iUnion_exists, iUnion_iUnion_eq']
 #align Union_Ici_eq_Ioi_infi iUnion_Ici_eq_Ioi_iInf
 
 theorem iUnion_Iic_eq_Iio_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
-    (no_greatest_elem : (⨆ i, f i) ∉ range f) : (⋃ i : ι, Iic (f i)) = Iio (⨆ i, f i) :=
+    (no_greatest_elem : (⨆ i, f i) ∉ range f) : ⋃ i : ι, Iic (f i) = Iio (⨆ i, f i) :=
   @iUnion_Ici_eq_Ioi_iInf ι (OrderDual R) _ f no_greatest_elem
 #align Union_Iic_eq_Iio_supr iUnion_Iic_eq_Iio_iSup
 
 theorem iUnion_Ici_eq_Ici_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
-    (has_least_elem : (⨅ i, f i) ∈ range f) : (⋃ i : ι, Ici (f i)) = Ici (⨅ i, f i) := by
+    (has_least_elem : (⨅ i, f i) ∈ range f) : ⋃ i : ι, Ici (f i) = Ici (⨅ i, f i) := by
   simp only [← IsGLB.biUnion_Ici_eq_Ici (@isGLB_iInf _ _ _ f) has_least_elem, mem_range,
     iUnion_exists, iUnion_iUnion_eq']
 #align Union_Ici_eq_Ici_infi iUnion_Ici_eq_Ici_iInf
 
 theorem iUnion_Iic_eq_Iic_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
-    (has_greatest_elem : (⨆ i, f i) ∈ range f) : (⋃ i : ι, Iic (f i)) = Iic (⨆ i, f i) :=
+    (has_greatest_elem : (⨆ i, f i) ∈ range f) : ⋃ i : ι, Iic (f i) = Iic (⨆ i, f i) :=
   @iUnion_Ici_eq_Ici_iInf ι (OrderDual R) _ f has_greatest_elem
 #align Union_Iic_eq_Iic_supr iUnion_Iic_eq_Iic_iSup
 

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>

@@ -64,64 +64,64 @@ theorem Iic_disjoint_Ici : Disjoint (Iic a) (Ici b) ↔ ¬b ≤ a :=
 #align set.Iic_disjoint_Ici Set.Iic_disjoint_Ici
 
 @[simp]
-theorem unionᵢ_Iic : (⋃ a : α, Iic a) = univ :=
-  unionᵢ_eq_univ_iff.2 fun x => ⟨x, right_mem_Iic⟩
-#align set.Union_Iic Set.unionᵢ_Iic
+theorem iUnion_Iic : (⋃ a : α, Iic a) = univ :=
+  iUnion_eq_univ_iff.2 fun x => ⟨x, right_mem_Iic⟩
+#align set.Union_Iic Set.iUnion_Iic
 
 @[simp]
-theorem unionᵢ_Ici : (⋃ a : α, Ici a) = univ :=
-  unionᵢ_eq_univ_iff.2 fun x => ⟨x, left_mem_Ici⟩
-#align set.Union_Ici Set.unionᵢ_Ici
+theorem iUnion_Ici : (⋃ a : α, Ici a) = univ :=
+  iUnion_eq_univ_iff.2 fun x => ⟨x, left_mem_Ici⟩
+#align set.Union_Ici Set.iUnion_Ici
 
 @[simp]
-theorem unionᵢ_Icc_right (a : α) : (⋃ b, Icc a b) = Ici a := by
-  simp only [← Ici_inter_Iic, ← inter_unionᵢ, unionᵢ_Iic, inter_univ]
-#align set.Union_Icc_right Set.unionᵢ_Icc_right
+theorem iUnion_Icc_right (a : α) : (⋃ b, Icc a b) = Ici a := by
+  simp only [← Ici_inter_Iic, ← inter_iUnion, iUnion_Iic, inter_univ]
+#align set.Union_Icc_right Set.iUnion_Icc_right
 
 @[simp]
-theorem unionᵢ_Ioc_right (a : α) : (⋃ b, Ioc a b) = Ioi a := by
-  simp only [← Ioi_inter_Iic, ← inter_unionᵢ, unionᵢ_Iic, inter_univ]
-#align set.Union_Ioc_right Set.unionᵢ_Ioc_right
+theorem iUnion_Ioc_right (a : α) : (⋃ b, Ioc a b) = Ioi a := by
+  simp only [← Ioi_inter_Iic, ← inter_iUnion, iUnion_Iic, inter_univ]
+#align set.Union_Ioc_right Set.iUnion_Ioc_right
 
 @[simp]
-theorem unionᵢ_Icc_left (b : α) : (⋃ a, Icc a b) = Iic b := by
-  simp only [← Ici_inter_Iic, ← unionᵢ_inter, unionᵢ_Ici, univ_inter]
-#align set.Union_Icc_left Set.unionᵢ_Icc_left
+theorem iUnion_Icc_left (b : α) : (⋃ a, Icc a b) = Iic b := by
+  simp only [← Ici_inter_Iic, ← iUnion_inter, iUnion_Ici, univ_inter]
+#align set.Union_Icc_left Set.iUnion_Icc_left
 
 @[simp]
-theorem unionᵢ_Ico_left (b : α) : (⋃ a, Ico a b) = Iio b := by
-  simp only [← Ici_inter_Iio, ← unionᵢ_inter, unionᵢ_Ici, univ_inter]
-#align set.Union_Ico_left Set.unionᵢ_Ico_left
+theorem iUnion_Ico_left (b : α) : (⋃ a, Ico a b) = Iio b := by
+  simp only [← Ici_inter_Iio, ← iUnion_inter, iUnion_Ici, univ_inter]
+#align set.Union_Ico_left Set.iUnion_Ico_left
 
 @[simp]
-theorem unionᵢ_Iio [NoMaxOrder α] : (⋃ a : α, Iio a) = univ :=
-  unionᵢ_eq_univ_iff.2 exists_gt
-#align set.Union_Iio Set.unionᵢ_Iio
+theorem iUnion_Iio [NoMaxOrder α] : (⋃ a : α, Iio a) = univ :=
+  iUnion_eq_univ_iff.2 exists_gt
+#align set.Union_Iio Set.iUnion_Iio
 
 @[simp]
-theorem unionᵢ_Ioi [NoMinOrder α] : (⋃ a : α, Ioi a) = univ :=
-  unionᵢ_eq_univ_iff.2 exists_lt
-#align set.Union_Ioi Set.unionᵢ_Ioi
+theorem iUnion_Ioi [NoMinOrder α] : (⋃ a : α, Ioi a) = univ :=
+  iUnion_eq_univ_iff.2 exists_lt
+#align set.Union_Ioi Set.iUnion_Ioi
 
 @[simp]
-theorem unionᵢ_Ico_right [NoMaxOrder α] (a : α) : (⋃ b, Ico a b) = Ici a := by
-  simp only [← Ici_inter_Iio, ← inter_unionᵢ, unionᵢ_Iio, inter_univ]
-#align set.Union_Ico_right Set.unionᵢ_Ico_right
+theorem iUnion_Ico_right [NoMaxOrder α] (a : α) : (⋃ b, Ico a b) = Ici a := by
+  simp only [← Ici_inter_Iio, ← inter_iUnion, iUnion_Iio, inter_univ]
+#align set.Union_Ico_right Set.iUnion_Ico_right
 
 @[simp]
-theorem unionᵢ_Ioo_right [NoMaxOrder α] (a : α) : (⋃ b, Ioo a b) = Ioi a := by
-  simp only [← Ioi_inter_Iio, ← inter_unionᵢ, unionᵢ_Iio, inter_univ]
-#align set.Union_Ioo_right Set.unionᵢ_Ioo_right
+theorem iUnion_Ioo_right [NoMaxOrder α] (a : α) : (⋃ b, Ioo a b) = Ioi a := by
+  simp only [← Ioi_inter_Iio, ← inter_iUnion, iUnion_Iio, inter_univ]
+#align set.Union_Ioo_right Set.iUnion_Ioo_right
 
 @[simp]
-theorem unionᵢ_Ioc_left [NoMinOrder α] (b : α) : (⋃ a, Ioc a b) = Iic b := by
-  simp only [← Ioi_inter_Iic, ← unionᵢ_inter, unionᵢ_Ioi, univ_inter]
-#align set.Union_Ioc_left Set.unionᵢ_Ioc_left
+theorem iUnion_Ioc_left [NoMinOrder α] (b : α) : (⋃ a, Ioc a b) = Iic b := by
+  simp only [← Ioi_inter_Iic, ← iUnion_inter, iUnion_Ioi, univ_inter]
+#align set.Union_Ioc_left Set.iUnion_Ioc_left
 
 @[simp]
-theorem unionᵢ_Ioo_left [NoMinOrder α] (b : α) : (⋃ a, Ioo a b) = Iio b := by
-  simp only [← Ioi_inter_Iio, ← unionᵢ_inter, unionᵢ_Ioi, univ_inter]
-#align set.Union_Ioo_left Set.unionᵢ_Ioo_left
+theorem iUnion_Ioo_left [NoMinOrder α] (b : α) : (⋃ a, Ioo a b) = Iio b := by
+  simp only [← Ioi_inter_Iio, ← iUnion_inter, iUnion_Ioi, univ_inter]
+#align set.Union_Ioo_left Set.iUnion_Ioo_left
 
 end Preorder
 
@@ -151,28 +151,28 @@ theorem eq_of_Ico_disjoint {x₁ x₂ y₁ y₂ : α} (h : Disjoint (Ico x₁ x
 #align set.eq_of_Ico_disjoint Set.eq_of_Ico_disjoint
 
 @[simp]
-theorem unionᵢ_Ico_eq_Iio_self_iff {f : ι → α} {a : α} :
+theorem iUnion_Ico_eq_Iio_self_iff {f : ι → α} {a : α} :
     (⋃ i, Ico (f i) a) = Iio a ↔ ∀ x < a, ∃ i, f i ≤ x := by
-  simp [← Ici_inter_Iio, ← unionᵢ_inter, subset_def]
-#align set.Union_Ico_eq_Iio_self_iff Set.unionᵢ_Ico_eq_Iio_self_iff
+  simp [← Ici_inter_Iio, ← iUnion_inter, subset_def]
+#align set.Union_Ico_eq_Iio_self_iff Set.iUnion_Ico_eq_Iio_self_iff
 
 @[simp]
-theorem unionᵢ_Ioc_eq_Ioi_self_iff {f : ι → α} {a : α} :
+theorem iUnion_Ioc_eq_Ioi_self_iff {f : ι → α} {a : α} :
     (⋃ i, Ioc a (f i)) = Ioi a ↔ ∀ x, a < x → ∃ i, x ≤ f i := by
-  simp [← Ioi_inter_Iic, ← inter_unionᵢ, subset_def]
-#align set.Union_Ioc_eq_Ioi_self_iff Set.unionᵢ_Ioc_eq_Ioi_self_iff
+  simp [← Ioi_inter_Iic, ← inter_iUnion, subset_def]
+#align set.Union_Ioc_eq_Ioi_self_iff Set.iUnion_Ioc_eq_Ioi_self_iff
 
 @[simp]
-theorem bunionᵢ_Ico_eq_Iio_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
+theorem biUnion_Ico_eq_Iio_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
     (⋃ (i) (hi : p i), Ico (f i hi) a) = Iio a ↔ ∀ x < a, ∃ i hi, f i hi ≤ x := by
-  simp [← Ici_inter_Iio, ← unionᵢ_inter, subset_def]
-#align set.bUnion_Ico_eq_Iio_self_iff Set.bunionᵢ_Ico_eq_Iio_self_iff
+  simp [← Ici_inter_Iio, ← iUnion_inter, subset_def]
+#align set.bUnion_Ico_eq_Iio_self_iff Set.biUnion_Ico_eq_Iio_self_iff
 
 @[simp]
-theorem bunionᵢ_Ioc_eq_Ioi_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
+theorem biUnion_Ioc_eq_Ioi_self_iff {p : ι → Prop} {f : ∀ i, p i → α} {a : α} :
     (⋃ (i) (hi : p i), Ioc a (f i hi)) = Ioi a ↔ ∀ x, a < x → ∃ i hi, x ≤ f i hi := by
-  simp [← Ioi_inter_Iic, ← inter_unionᵢ, subset_def]
-#align set.bUnion_Ioc_eq_Ioi_self_iff Set.bunionᵢ_Ioc_eq_Ioi_self_iff
+  simp [← Ioi_inter_Iic, ← inter_iUnion, subset_def]
+#align set.bUnion_Ioc_eq_Ioi_self_iff Set.biUnion_Ioc_eq_Ioi_self_iff
 
 end LinearOrder
 
@@ -182,71 +182,71 @@ section UnionIxx
 
 variable [LinearOrder α] {s : Set α} {a : α} {f : ι → α}
 
-theorem IsGLB.bunionᵢ_Ioi_eq (h : IsGLB s a) : (⋃ x ∈ s, Ioi x) = Ioi a := by
-  refine' (unionᵢ₂_subset fun x hx => _).antisymm fun x hx => _
+theorem IsGLB.biUnion_Ioi_eq (h : IsGLB s a) : (⋃ x ∈ s, Ioi x) = Ioi a := by
+  refine' (iUnion₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ioi_subset_Ioi (h.1 hx)
   · rcases h.exists_between hx with ⟨y, hys, _, hyx⟩
-    exact mem_bunionᵢ hys hyx
-#align is_glb.bUnion_Ioi_eq IsGLB.bunionᵢ_Ioi_eq
+    exact mem_biUnion hys hyx
+#align is_glb.bUnion_Ioi_eq IsGLB.biUnion_Ioi_eq
 
-theorem IsGLB.unionᵢ_Ioi_eq (h : IsGLB (range f) a) : (⋃ x, Ioi (f x)) = Ioi a :=
-  bunionᵢ_range.symm.trans h.bunionᵢ_Ioi_eq
-#align is_glb.Union_Ioi_eq IsGLB.unionᵢ_Ioi_eq
+theorem IsGLB.iUnion_Ioi_eq (h : IsGLB (range f) a) : (⋃ x, Ioi (f x)) = Ioi a :=
+  biUnion_range.symm.trans h.biUnion_Ioi_eq
+#align is_glb.Union_Ioi_eq IsGLB.iUnion_Ioi_eq
 
-theorem IsLUB.bunionᵢ_Iio_eq (h : IsLUB s a) : (⋃ x ∈ s, Iio x) = Iio a :=
-  h.dual.bunionᵢ_Ioi_eq
-#align is_lub.bUnion_Iio_eq IsLUB.bunionᵢ_Iio_eq
+theorem IsLUB.biUnion_Iio_eq (h : IsLUB s a) : (⋃ x ∈ s, Iio x) = Iio a :=
+  h.dual.biUnion_Ioi_eq
+#align is_lub.bUnion_Iio_eq IsLUB.biUnion_Iio_eq
 
-theorem IsLUB.unionᵢ_Iio_eq (h : IsLUB (range f) a) : (⋃ x, Iio (f x)) = Iio a :=
-  h.dual.unionᵢ_Ioi_eq
-#align is_lub.Union_Iio_eq IsLUB.unionᵢ_Iio_eq
+theorem IsLUB.iUnion_Iio_eq (h : IsLUB (range f) a) : (⋃ x, Iio (f x)) = Iio a :=
+  h.dual.iUnion_Ioi_eq
+#align is_lub.Union_Iio_eq IsLUB.iUnion_Iio_eq
 
-theorem IsGLB.bunionᵢ_Ici_eq_Ioi (a_glb : IsGLB s a) (a_not_mem : a ∉ s) :
+theorem IsGLB.biUnion_Ici_eq_Ioi (a_glb : IsGLB s a) (a_not_mem : a ∉ s) :
     (⋃ x ∈ s, Ici x) = Ioi a := by
-  refine' (unionᵢ₂_subset fun x hx => _).antisymm fun x hx => _
+  refine' (iUnion₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ici_subset_Ioi.mpr (lt_of_le_of_ne (a_glb.1 hx) fun h => (h ▸ a_not_mem) hx)
   · rcases a_glb.exists_between hx with ⟨y, hys, _, hyx⟩
-    apply mem_unionᵢ₂.mpr
+    apply mem_iUnion₂.mpr
     refine' ⟨y, hys, hyx.le⟩
-#align is_glb.bUnion_Ici_eq_Ioi IsGLB.bunionᵢ_Ici_eq_Ioi
+#align is_glb.bUnion_Ici_eq_Ioi IsGLB.biUnion_Ici_eq_Ioi
 
-theorem IsGLB.bunionᵢ_Ici_eq_Ici (a_glb : IsGLB s a) (a_mem : a ∈ s) :
+theorem IsGLB.biUnion_Ici_eq_Ici (a_glb : IsGLB s a) (a_mem : a ∈ s) :
     (⋃ x ∈ s, Ici x) = Ici a := by
-  refine' (unionᵢ₂_subset fun x hx => _).antisymm fun x hx => _
+  refine' (iUnion₂_subset fun x hx => _).antisymm fun x hx => _
   · exact Ici_subset_Ici.mpr (mem_lowerBounds.mp a_glb.1 x hx)
-  · apply mem_unionᵢ₂.mpr
+  · apply mem_iUnion₂.mpr
     refine' ⟨a, a_mem, hx⟩
-#align is_glb.bUnion_Ici_eq_Ici IsGLB.bunionᵢ_Ici_eq_Ici
+#align is_glb.bUnion_Ici_eq_Ici IsGLB.biUnion_Ici_eq_Ici
 
-theorem IsLUB.bunionᵢ_Iic_eq_Iio (a_lub : IsLUB s a) (a_not_mem : a ∉ s) :
+theorem IsLUB.biUnion_Iic_eq_Iio (a_lub : IsLUB s a) (a_not_mem : a ∉ s) :
     (⋃ x ∈ s, Iic x) = Iio a :=
-  a_lub.dual.bunionᵢ_Ici_eq_Ioi a_not_mem
-#align is_lub.bUnion_Iic_eq_Iio IsLUB.bunionᵢ_Iic_eq_Iio
+  a_lub.dual.biUnion_Ici_eq_Ioi a_not_mem
+#align is_lub.bUnion_Iic_eq_Iio IsLUB.biUnion_Iic_eq_Iio
 
-theorem IsLUB.bunionᵢ_Iic_eq_Iic (a_lub : IsLUB s a) (a_mem : a ∈ s) : (⋃ x ∈ s, Iic x) = Iic a :=
-  a_lub.dual.bunionᵢ_Ici_eq_Ici a_mem
-#align is_lub.bUnion_Iic_eq_Iic IsLUB.bunionᵢ_Iic_eq_Iic
+theorem IsLUB.biUnion_Iic_eq_Iic (a_lub : IsLUB s a) (a_mem : a ∈ s) : (⋃ x ∈ s, Iic x) = Iic a :=
+  a_lub.dual.biUnion_Ici_eq_Ici a_mem
+#align is_lub.bUnion_Iic_eq_Iic IsLUB.biUnion_Iic_eq_Iic
 
-theorem unionᵢ_Ici_eq_Ioi_infᵢ {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+theorem iUnion_Ici_eq_Ioi_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (no_least_elem : (⨅ i, f i) ∉ range f) : (⋃ i : ι, Ici (f i)) = Ioi (⨅ i, f i) := by
-  simp only [← IsGLB.bunionᵢ_Ici_eq_Ioi (@isGLB_infᵢ _ _ _ f) no_least_elem, mem_range,
-    unionᵢ_exists, unionᵢ_unionᵢ_eq']
-#align Union_Ici_eq_Ioi_infi unionᵢ_Ici_eq_Ioi_infᵢ
+  simp only [← IsGLB.biUnion_Ici_eq_Ioi (@isGLB_iInf _ _ _ f) no_least_elem, mem_range,
+    iUnion_exists, iUnion_iUnion_eq']
+#align Union_Ici_eq_Ioi_infi iUnion_Ici_eq_Ioi_iInf
 
-theorem unionᵢ_Iic_eq_Iio_supᵢ {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+theorem iUnion_Iic_eq_Iio_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (no_greatest_elem : (⨆ i, f i) ∉ range f) : (⋃ i : ι, Iic (f i)) = Iio (⨆ i, f i) :=
-  @unionᵢ_Ici_eq_Ioi_infᵢ ι (OrderDual R) _ f no_greatest_elem
-#align Union_Iic_eq_Iio_supr unionᵢ_Iic_eq_Iio_supᵢ
+  @iUnion_Ici_eq_Ioi_iInf ι (OrderDual R) _ f no_greatest_elem
+#align Union_Iic_eq_Iio_supr iUnion_Iic_eq_Iio_iSup
 
-theorem unionᵢ_Ici_eq_Ici_infᵢ {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+theorem iUnion_Ici_eq_Ici_iInf {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (has_least_elem : (⨅ i, f i) ∈ range f) : (⋃ i : ι, Ici (f i)) = Ici (⨅ i, f i) := by
-  simp only [← IsGLB.bunionᵢ_Ici_eq_Ici (@isGLB_infᵢ _ _ _ f) has_least_elem, mem_range,
-    unionᵢ_exists, unionᵢ_unionᵢ_eq']
-#align Union_Ici_eq_Ici_infi unionᵢ_Ici_eq_Ici_infᵢ
+  simp only [← IsGLB.biUnion_Ici_eq_Ici (@isGLB_iInf _ _ _ f) has_least_elem, mem_range,
+    iUnion_exists, iUnion_iUnion_eq']
+#align Union_Ici_eq_Ici_infi iUnion_Ici_eq_Ici_iInf
 
-theorem unionᵢ_Iic_eq_Iic_supᵢ {R : Type _} [CompleteLinearOrder R] {f : ι → R}
+theorem iUnion_Iic_eq_Iic_iSup {R : Type _} [CompleteLinearOrder R] {f : ι → R}
     (has_greatest_elem : (⨆ i, f i) ∈ range f) : (⋃ i : ι, Iic (f i)) = Iic (⨆ i, f i) :=
-  @unionᵢ_Ici_eq_Ici_infᵢ ι (OrderDual R) _ f has_greatest_elem
-#align Union_Iic_eq_Iic_supr unionᵢ_Iic_eq_Iic_supᵢ
+  @iUnion_Ici_eq_Ici_iInf ι (OrderDual R) _ f has_greatest_elem
+#align Union_Iic_eq_Iic_supr iUnion_Iic_eq_Iic_iSup
 
 end UnionIxx

Match https://github.com/leanprover-community/mathlib/pull/17901 and https://github.com/leanprover-community/mathlib/pull/17957

@@ -60,7 +60,7 @@ theorem Ici_disjoint_Iic : Disjoint (Ici a) (Iic b) ↔ ¬a ≤ b := by
 
 @[simp]
 theorem Iic_disjoint_Ici : Disjoint (Iic a) (Ici b) ↔ ¬b ≤ a :=
-  Disjoint.comm.trans Ici_disjoint_Iic
+  disjoint_comm.trans Ici_disjoint_Iic
 #align set.Iic_disjoint_Ici Set.Iic_disjoint_Ici
 
 @[simp]