data.set.intervals.unordered_interval | Mathlib porting status

(last sync)

feat(analysis/convex/proj_Icc): Extending convex functions (#18797)

Constantly extending monotone/antitone functions preserves their convexity.

Diff

@@ -129,7 +129,30 @@ by simpa only [uIcc_comm] using uIcc_injective_right a
 end distrib_lattice
 
 section linear_order
-variables [linear_order α] [linear_order β] {f : α → β} {s : set α} {a a₁ a₂ b b₁ b₂ c d x : α}
+variables [linear_order α]
+
+section lattice
+variables [lattice β] {f : α → β} {s : set α} {a b : α}
+
+lemma _root_.monotone_on.image_uIcc_subset (hf : monotone_on f (uIcc a b)) :
+  f '' uIcc a b ⊆ uIcc (f a) (f b) :=
+hf.image_Icc_subset.trans $
+  by rw [hf.map_sup left_mem_uIcc right_mem_uIcc, hf.map_inf left_mem_uIcc right_mem_uIcc, uIcc]
+
+lemma _root_.antitone_on.image_uIcc_subset (hf : antitone_on f (uIcc a b)) :
+  f '' uIcc a b ⊆ uIcc (f a) (f b) :=
+hf.image_Icc_subset.trans $
+  by rw [hf.map_sup left_mem_uIcc right_mem_uIcc, hf.map_inf left_mem_uIcc right_mem_uIcc, uIcc]
+
+lemma _root_.monotone.image_uIcc_subset (hf : monotone f) : f '' uIcc a b ⊆ uIcc (f a) (f b) :=
+(hf.monotone_on _).image_uIcc_subset
+
+lemma _root_.antitone.image_uIcc_subset (hf : antitone f) : f '' uIcc a b ⊆ uIcc (f a) (f b) :=
+(hf.antitone_on _).image_uIcc_subset
+
+end lattice
+
+variables [linear_order β] {f : α → β} {s : set α} {a a₁ a₂ b b₁ b₂ c d x : α}
 
 lemma Icc_min_max : Icc (min a b) (max a b) = [a, b] := rfl

feat(data/set/intervals/unordered_interval): prod and pi lemmas (#18835)

Diff

@@ -41,7 +41,7 @@ variables {α β : Type*}
 
 namespace set
 section lattice
-variables [lattice α] {a a₁ a₂ b b₁ b₂ c x : α}
+variables [lattice α] [lattice β] {a a₁ a₂ b b₁ b₂ c x : α}
 
 /-- `uIcc a b` is the set of elements lying between `a` and `b`, with `a` and `b` included.
 Note that we define it more generally in a lattice as `set.Icc (a ⊓ b) (a ⊔ b)`. In a product type,
@@ -96,6 +96,16 @@ lemma bdd_below_bdd_above_iff_subset_uIcc (s : set α) :
 bdd_below_bdd_above_iff_subset_Icc.trans
   ⟨λ ⟨a, b, h⟩, ⟨a, b, λ x hx, Icc_subset_uIcc (h hx)⟩, λ ⟨a, b, h⟩, ⟨_, _, h⟩⟩
 
+section prod
+
+@[simp] lemma uIcc_prod_uIcc (a₁ a₂ : α) (b₁ b₂ : β) :
+  [a₁, a₂] ×ˢ [b₁, b₂] = [(a₁, b₁), (a₂, b₂)] :=
+Icc_prod_Icc _ _ _ _
+
+lemma uIcc_prod_eq (a b : α × β) : [a, b] = [a.1, b.1] ×ˢ [a.2, b.2] := by simp
+
+end prod
+
 end lattice
 
 open_locale interval

Zulip: https://leanprover.zulipchat.com/#narrow/stream/116395-maths/topic/Set.20intervals.20names

chore(data/set/intervals/unordered_interval): Rename to uIcc/uIoc (#18104)

Rename

set.interval → set.uIcc
set.interval_oc → set.uIoc
finset.interval→ finset.uIcc

Closes #17982

Diff

@@ -12,25 +12,25 @@ import data.set.intervals.basic
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
 > Any changes to this file require a corresponding PR to mathlib4.
 
-In any lattice `α`, we define `interval a b` to be `Icc (a ⊓ b) (a ⊔ b)`, which in a linear order is
-the set of elements lying between `a` and `b`.
+In any lattice `α`, we define `uIcc a b` to be `Icc (a ⊓ b) (a ⊔ b)`, which in a linear order is the
+set of elements lying between `a` and `b`.
 
 `Icc a b` requires the assumption `a ≤ b` to be meaningful, which is sometimes inconvenient. The
 interval as defined in this file is always the set of things lying between `a` and `b`, regardless
 of the relative order of `a` and `b`.
 
-For real numbers, `interval a b` is the same as `segment ℝ a b`.
+For real numbers, `uIcc a b` is the same as `segment ℝ a b`.
 
-In a product or pi type, `interval a b` is the smallest box containing `a` and `b`. For example,
-`interval (1, -1) (-1, 1) = Icc (-1, -1) (1, 1)` is the square of vertices `(1, -1)`, `(-1, -1)`,
+In a product or pi type, `uIcc a b` is the smallest box containing `a` and `b`. For example,
+`uIcc (1, -1) (-1, 1) = Icc (-1, -1) (1, 1)` is the square of vertices `(1, -1)`, `(-1, -1)`,
 `(-1, 1)`, `(1, 1)`.
 
-In `finset α` (seen as a hypercube of dimension `fintype.card α`), `interval a b` is the smallest
+In `finset α` (seen as a hypercube of dimension `fintype.card α`), `uIcc a b` is the smallest
 subcube containing both `a` and `b`.
 
 ## Notation
 
-We use the localized notation `[a, b]` for `interval a b`. One can open the locale `interval` to
+We use the localized notation `[a, b]` for `uIcc a b`. One can open the locale `interval` to
 make the notation available.
 
 -/
@@ -43,65 +43,58 @@ namespace set
 section lattice
 variables [lattice α] {a a₁ a₂ b b₁ b₂ c x : α}
 
-/-- `interval a b` is the set of elements lying between `a` and `b`, with `a` and `b` included.
+/-- `uIcc a b` is the set of elements lying between `a` and `b`, with `a` and `b` included.
 Note that we define it more generally in a lattice as `set.Icc (a ⊓ b) (a ⊔ b)`. In a product type,
-`interval` corresponds to the bounding box of the two elements. -/
-def interval (a b : α) : set α := Icc (a ⊓ b) (a ⊔ b)
+`uIcc` corresponds to the bounding box of the two elements. -/
+def uIcc (a b : α) : set α := Icc (a ⊓ b) (a ⊔ b)
 
-localized "notation (name := set.interval) `[`a `, ` b `]` := set.interval a b" in interval
+localized "notation (name := set.uIcc) `[`a `, ` b `]` := set.uIcc a b" in interval
 
-@[simp] lemma dual_interval (a b : α) : [to_dual a, to_dual b] = of_dual ⁻¹' [a, b] := dual_Icc
+@[simp] lemma dual_uIcc (a b : α) : [to_dual a, to_dual b] = of_dual ⁻¹' [a, b] := dual_Icc
 
-@[simp] lemma interval_of_le (h : a ≤ b) : [a, b] = Icc a b :=
-by rw [interval, inf_eq_left.2 h, sup_eq_right.2 h]
+@[simp] lemma uIcc_of_le (h : a ≤ b) : [a, b] = Icc a b :=
+by rw [uIcc, inf_eq_left.2 h, sup_eq_right.2 h]
 
-@[simp] lemma interval_of_ge (h : b ≤ a) : [a, b] = Icc b a :=
-by rw [interval, inf_eq_right.2 h, sup_eq_left.2 h]
+@[simp] lemma uIcc_of_ge (h : b ≤ a) : [a, b] = Icc b a :=
+by rw [uIcc, inf_eq_right.2 h, sup_eq_left.2 h]
 
-lemma interval_swap (a b : α) : [a, b] = [b, a] := by simp_rw [interval, inf_comm, sup_comm]
+lemma uIcc_comm (a b : α) : [a, b] = [b, a] := by simp_rw [uIcc, inf_comm, sup_comm]
 
-lemma interval_of_lt (h : a < b) : [a, b] = Icc a b :=
-interval_of_le (le_of_lt h)
+lemma uIcc_of_lt (h : a < b) : [a, b] = Icc a b := uIcc_of_le h.le
+lemma uIcc_of_gt (h : b < a) : [a, b] = Icc b a := uIcc_of_ge h.le
 
-lemma interval_of_gt (h : b < a) : [a, b] = Icc b a :=
-interval_of_ge (le_of_lt h)
+@[simp] lemma uIcc_self : [a, a] = {a} := by simp [uIcc]
 
-@[simp] lemma interval_self : [a, a] = {a} := by simp [interval]
+@[simp] lemma nonempty_uIcc : [a, b].nonempty := nonempty_Icc.2 inf_le_sup
 
-@[simp] lemma nonempty_interval : [a, b].nonempty := nonempty_Icc.2 inf_le_sup
+lemma Icc_subset_uIcc : Icc a b ⊆ [a, b] := Icc_subset_Icc inf_le_left le_sup_right
+lemma Icc_subset_uIcc' : Icc b a ⊆ [a, b] := Icc_subset_Icc inf_le_right le_sup_left
 
-lemma Icc_subset_interval : Icc a b ⊆ [a, b] := Icc_subset_Icc inf_le_left le_sup_right
-lemma Icc_subset_interval' : Icc b a ⊆ [a, b] := Icc_subset_Icc inf_le_right le_sup_left
+@[simp] lemma left_mem_uIcc : a ∈ [a, b] := ⟨inf_le_left, le_sup_left⟩
+@[simp] lemma right_mem_uIcc : b ∈ [a, b] := ⟨inf_le_right, le_sup_right⟩
 
-@[simp] lemma left_mem_interval : a ∈ [a, b] := ⟨inf_le_left, le_sup_left⟩
-@[simp] lemma right_mem_interval : b ∈ [a, b] := ⟨inf_le_right, le_sup_right⟩
+lemma mem_uIcc_of_le (ha : a ≤ x) (hb : x ≤ b) : x ∈ [a, b] := Icc_subset_uIcc ⟨ha, hb⟩
+lemma mem_uIcc_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [a, b] := Icc_subset_uIcc' ⟨hb, ha⟩
 
-lemma mem_interval_of_le (ha : a ≤ x) (hb : x ≤ b) : x ∈ [a, b] := Icc_subset_interval ⟨ha, hb⟩
-lemma mem_interval_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [a, b] := Icc_subset_interval' ⟨hb, ha⟩
-
-lemma interval_subset_interval (h₁ : a₁ ∈ [a₂, b₂]) (h₂ : b₁ ∈ [a₂, b₂]) : [a₁, b₁] ⊆ [a₂, b₂] :=
+lemma uIcc_subset_uIcc (h₁ : a₁ ∈ [a₂, b₂]) (h₂ : b₁ ∈ [a₂, b₂]) : [a₁, b₁] ⊆ [a₂, b₂] :=
 Icc_subset_Icc (le_inf h₁.1 h₂.1) (sup_le h₁.2 h₂.2)
 
-lemma interval_subset_Icc (ha : a₁ ∈ Icc a₂ b₂) (hb : b₁ ∈ Icc a₂ b₂) : [a₁, b₁] ⊆ Icc a₂ b₂ :=
+lemma uIcc_subset_Icc (ha : a₁ ∈ Icc a₂ b₂) (hb : b₁ ∈ Icc a₂ b₂) : [a₁, b₁] ⊆ Icc a₂ b₂ :=
 Icc_subset_Icc (le_inf ha.1 hb.1) (sup_le ha.2 hb.2)
 
-lemma interval_subset_interval_iff_mem : [a₁, b₁] ⊆ [a₂, b₂] ↔ a₁ ∈ [a₂, b₂] ∧ b₁ ∈ [a₂, b₂] :=
-iff.intro (λh, ⟨h left_mem_interval, h right_mem_interval⟩) (λ h, interval_subset_interval h.1 h.2)
+lemma uIcc_subset_uIcc_iff_mem : [a₁, b₁] ⊆ [a₂, b₂] ↔ a₁ ∈ [a₂, b₂] ∧ b₁ ∈ [a₂, b₂] :=
+iff.intro (λh, ⟨h left_mem_uIcc, h right_mem_uIcc⟩) (λ h, uIcc_subset_uIcc h.1 h.2)
 
-lemma interval_subset_interval_iff_le' :
-  [a₁, b₁] ⊆ [a₂, b₂] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂ :=
+lemma uIcc_subset_uIcc_iff_le' : [a₁, b₁] ⊆ [a₂, b₂] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂ :=
 Icc_subset_Icc_iff inf_le_sup
 
-lemma interval_subset_interval_right (h : x ∈ [a, b]) : [x, b] ⊆ [a, b] :=
-interval_subset_interval h right_mem_interval
-
-lemma interval_subset_interval_left (h : x ∈ [a, b]) : [a, x] ⊆ [a, b] :=
-interval_subset_interval left_mem_interval h
+lemma uIcc_subset_uIcc_right (h : x ∈ [a, b]) : [x, b] ⊆ [a, b] := uIcc_subset_uIcc h right_mem_uIcc
+lemma uIcc_subset_uIcc_left (h : x ∈ [a, b]) : [a, x] ⊆ [a, b] := uIcc_subset_uIcc left_mem_uIcc h
 
-lemma bdd_below_bdd_above_iff_subset_interval (s : set α) :
+lemma bdd_below_bdd_above_iff_subset_uIcc (s : set α) :
   bdd_below s ∧ bdd_above s ↔ ∃ a b, s ⊆ [a, b] :=
 bdd_below_bdd_above_iff_subset_Icc.trans
-  ⟨λ ⟨a, b, h⟩, ⟨a, b, λ x hx, Icc_subset_interval (h hx)⟩, λ ⟨a, b, h⟩, ⟨_, _, h⟩⟩
+  ⟨λ ⟨a, b, h⟩, ⟨a, b, λ x hx, Icc_subset_uIcc (h hx)⟩, λ ⟨a, b, h⟩, ⟨_, _, h⟩⟩
 
 end lattice
 
@@ -110,49 +103,48 @@ open_locale interval
 section distrib_lattice
 variables [distrib_lattice α] {a a₁ a₂ b b₁ b₂ c x : α}
 
-lemma eq_of_mem_interval_of_mem_interval (ha : a ∈ [b, c]) (hb : b ∈ [a, c]) : a = b :=
+lemma eq_of_mem_uIcc_of_mem_uIcc (ha : a ∈ [b, c]) (hb : b ∈ [a, c]) : a = b :=
 eq_of_inf_eq_sup_eq (inf_congr_right ha.1 hb.1) $ sup_congr_right ha.2 hb.2
 
-lemma eq_of_mem_interval_of_mem_interval' : b ∈ [a, c] → c ∈ [a, b] → b = c :=
-by simpa only [interval_swap a] using eq_of_mem_interval_of_mem_interval
+lemma eq_of_mem_uIcc_of_mem_uIcc' : b ∈ [a, c] → c ∈ [a, b] → b = c :=
+by simpa only [uIcc_comm a] using eq_of_mem_uIcc_of_mem_uIcc
 
-lemma interval_injective_right (a : α) : injective (λ b, interval b a) :=
+lemma uIcc_injective_right (a : α) : injective (λ b, uIcc b a) :=
 λ b c h, by { rw ext_iff at h,
-  exact eq_of_mem_interval_of_mem_interval ((h _).1 left_mem_interval) ((h _).2 left_mem_interval) }
+  exact eq_of_mem_uIcc_of_mem_uIcc ((h _).1 left_mem_uIcc) ((h _).2 left_mem_uIcc) }
 
-lemma interval_injective_left (a : α) : injective (interval a) :=
-by simpa only [interval_swap] using interval_injective_right a
+lemma uIcc_injective_left (a : α) : injective (uIcc a) :=
+by simpa only [uIcc_comm] using uIcc_injective_right a
 
 end distrib_lattice
 
 section linear_order
-variables [linear_order α] [linear_order β] {f : α → β} {s : set α}
-  {a a₁ a₂ b b₁ b₂ c x : α}
+variables [linear_order α] [linear_order β] {f : α → β} {s : set α} {a a₁ a₂ b b₁ b₂ c d x : α}
 
 lemma Icc_min_max : Icc (min a b) (max a b) = [a, b] := rfl
 
-lemma interval_of_not_le (h : ¬ a ≤ b) : [a, b] = Icc b a := interval_of_gt $ lt_of_not_ge h
-lemma interval_of_not_ge (h : ¬ b ≤ a) : [a, b] = Icc a b := interval_of_lt $ lt_of_not_ge h
+lemma uIcc_of_not_le (h : ¬ a ≤ b) : [a, b] = Icc b a := uIcc_of_gt $ lt_of_not_ge h
+lemma uIcc_of_not_ge (h : ¬ b ≤ a) : [a, b] = Icc a b := uIcc_of_lt $ lt_of_not_ge h
 
-lemma interval_eq_union : [a, b] = Icc a b ∪ Icc b a := by rw [Icc_union_Icc', max_comm]; refl
+lemma uIcc_eq_union : [a, b] = Icc a b ∪ Icc b a := by rw [Icc_union_Icc', max_comm]; refl
 
-lemma mem_interval : a ∈ [b, c] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b := by simp [interval_eq_union]
+lemma mem_uIcc : a ∈ [b, c] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b := by simp [uIcc_eq_union]
 
-lemma not_mem_interval_of_lt (ha : c < a) (hb : c < b) : c ∉ [a, b] :=
+lemma not_mem_uIcc_of_lt (ha : c < a) (hb : c < b) : c ∉ [a, b] :=
 not_mem_Icc_of_lt $ lt_min_iff.mpr ⟨ha, hb⟩
 
-lemma not_mem_interval_of_gt (ha : a < c) (hb : b < c) : c ∉ [a, b] :=
+lemma not_mem_uIcc_of_gt (ha : a < c) (hb : b < c) : c ∉ [a, b] :=
 not_mem_Icc_of_gt $ max_lt_iff.mpr ⟨ha, hb⟩
 
-lemma interval_subset_interval_iff_le :
+lemma uIcc_subset_uIcc_iff_le :
   [a₁, b₁] ⊆ [a₂, b₂] ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂ :=
-interval_subset_interval_iff_le'
+uIcc_subset_uIcc_iff_le'
 
 /-- A sort of triangle inequality. -/
-lemma interval_subset_interval_union_interval : [a, c] ⊆ [a, b] ∪ [b, c] :=
-λ x, by simp only [mem_interval, mem_union]; cases le_total a c; cases le_total x b; tauto
+lemma uIcc_subset_uIcc_union_uIcc : [a, c] ⊆ [a, b] ∪ [b, c] :=
+λ x, by simp only [mem_uIcc, mem_union]; cases le_total a c; cases le_total x b; tauto
 
-lemma monotone_or_antitone_iff_interval :
+lemma monotone_or_antitone_iff_uIcc :
   monotone f ∨ antitone f ↔ ∀ a b c, c ∈ [a, b] → f c ∈ [f a, f b] :=
 begin
   split,
@@ -161,85 +153,76 @@ begin
   contrapose!,
   rw not_monotone_not_antitone_iff_exists_le_le,
   rintro ⟨a, b, c, hab, hbc, ⟨hfab, hfcb⟩ | ⟨hfba, hfbc⟩⟩,
-  { exact ⟨a, c, b, Icc_subset_interval ⟨hab, hbc⟩, λ h, h.2.not_lt $ max_lt hfab hfcb⟩ },
-  { exact ⟨a, c, b, Icc_subset_interval ⟨hab, hbc⟩, λ h, h.1.not_lt $ lt_min hfba hfbc⟩ }
+  { exact ⟨a, c, b, Icc_subset_uIcc ⟨hab, hbc⟩, λ h, h.2.not_lt $ max_lt hfab hfcb⟩ },
+  { exact ⟨a, c, b, Icc_subset_uIcc ⟨hab, hbc⟩, λ h, h.1.not_lt $ lt_min hfba hfbc⟩ }
 end
 
-lemma monotone_on_or_antitone_on_iff_interval :
+lemma monotone_on_or_antitone_on_iff_uIcc :
   monotone_on f s ∨ antitone_on f s ↔ ∀ a b c ∈ s, c ∈ [a, b] → f c ∈ [f a, f b] :=
-by simp [monotone_on_iff_monotone, antitone_on_iff_antitone, monotone_or_antitone_iff_interval,
-  mem_interval]
+by simp [monotone_on_iff_monotone, antitone_on_iff_antitone, monotone_or_antitone_iff_uIcc,
+  mem_uIcc]
 
 /-- The open-closed interval with unordered bounds. -/
-def interval_oc : α → α → set α := λ a b, Ioc (min a b) (max a b)
+def uIoc : α → α → set α := λ a b, Ioc (min a b) (max a b)
 
 -- Below is a capital iota
-localized "notation `Ι` := set.interval_oc" in interval
+localized "notation `Ι` := set.uIoc" in interval
 
-@[simp] lemma interval_oc_of_le (h : a ≤ b) : Ι a b = Ioc a b :=
-by simp [interval_oc, h]
+@[simp] lemma uIoc_of_le (h : a ≤ b) : Ι a b = Ioc a b := by simp [uIoc, h]
+@[simp] lemma uIoc_of_lt (h : b < a) : Ι a b = Ioc b a := by simp [uIoc, h.le]
 
-@[simp] lemma interval_oc_of_lt (h : b < a) : Ι a b = Ioc b a :=
-by simp [interval_oc, le_of_lt h]
+lemma uIoc_eq_union : Ι a b = Ioc a b ∪ Ioc b a := by cases le_total a b; simp [uIoc, *]
 
-lemma interval_oc_eq_union : Ι a b = Ioc a b ∪ Ioc b a :=
-by cases le_total a b; simp [interval_oc, *]
+lemma mem_uIoc : a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b :=
+by simp only [uIoc_eq_union, mem_union, mem_Ioc]
 
-lemma mem_interval_oc : a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b :=
-by simp only [interval_oc_eq_union, mem_union, mem_Ioc]
+lemma not_mem_uIoc : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a :=
+by { simp only [uIoc_eq_union, mem_union, mem_Ioc, not_lt, ←not_le], tauto }
 
-lemma not_mem_interval_oc : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a :=
-by { simp only [interval_oc_eq_union, mem_union, mem_Ioc, not_lt, ←not_le], tauto }
+@[simp] lemma left_mem_uIoc : a ∈ Ι a b ↔ b < a := by simp [mem_uIoc]
+@[simp] lemma right_mem_uIoc : b ∈ Ι a b ↔ a < b := by simp [mem_uIoc]
 
-@[simp] lemma left_mem_interval_oc : a ∈ Ι a b ↔ b < a := by simp [mem_interval_oc]
-@[simp] lemma right_mem_interval_oc : b ∈ Ι a b ↔ a < b := by simp [mem_interval_oc]
-
-lemma forall_interval_oc_iff  {P : α → Prop} :
+lemma forall_uIoc_iff  {P : α → Prop} :
   (∀ x ∈ Ι a b, P x) ↔ (∀ x ∈ Ioc a b, P x) ∧ (∀ x ∈ Ioc b a, P x) :=
-by simp only [interval_oc_eq_union, mem_union, or_imp_distrib, forall_and_distrib]
-
-lemma interval_oc_subset_interval_oc_of_interval_subset_interval {a b c d : α}
-  (h : [a, b] ⊆ [c, d]) : Ι a b ⊆ Ι c d :=
-Ioc_subset_Ioc (interval_subset_interval_iff_le.1 h).1 (interval_subset_interval_iff_le.1 h).2
+by simp only [uIoc_eq_union, mem_union, or_imp_distrib, forall_and_distrib]
 
-lemma interval_oc_swap (a b : α) : Ι a b = Ι b a :=
-by simp only [interval_oc, min_comm a b, max_comm a b]
+lemma uIoc_subset_uIoc_of_uIcc_subset_uIcc (h : [a, b] ⊆ [c, d]) : Ι a b ⊆ Ι c d :=
+Ioc_subset_Ioc (uIcc_subset_uIcc_iff_le.1 h).1 (uIcc_subset_uIcc_iff_le.1 h).2
 
-lemma Ioc_subset_interval_oc : Ioc a b ⊆ Ι a b :=
-Ioc_subset_Ioc (min_le_left _ _) (le_max_right _ _)
+lemma uIoc_swap (a b : α) : Ι a b = Ι b a := by simp only [uIoc, min_comm a b, max_comm a b]
 
-lemma Ioc_subset_interval_oc' : Ioc a b ⊆ Ι b a :=
-Ioc_subset_Ioc (min_le_right _ _) (le_max_left _ _)
+lemma Ioc_subset_uIoc : Ioc a b ⊆ Ι a b := Ioc_subset_Ioc (min_le_left _ _) (le_max_right _ _)
+lemma Ioc_subset_uIoc' : Ioc a b ⊆ Ι b a := Ioc_subset_Ioc (min_le_right _ _) (le_max_left _ _)
 
-lemma eq_of_mem_interval_oc_of_mem_interval_oc : a ∈ Ι b c → b ∈ Ι a c → a = b :=
-by simp_rw mem_interval_oc; rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩); apply le_antisymm;
+lemma eq_of_mem_uIoc_of_mem_uIoc : a ∈ Ι b c → b ∈ Ι a c → a = b :=
+by simp_rw mem_uIoc; rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩); apply le_antisymm;
   assumption <|> exact le_of_lt ‹_› <|> exact le_trans ‹_› (le_of_lt ‹_›)
 
-lemma eq_of_mem_interval_oc_of_mem_interval_oc' : b ∈ Ι a c → c ∈ Ι a b → b = c :=
-by simpa only [interval_oc_swap a] using eq_of_mem_interval_oc_of_mem_interval_oc
+lemma eq_of_mem_uIoc_of_mem_uIoc' : b ∈ Ι a c → c ∈ Ι a b → b = c :=
+by simpa only [uIoc_swap a] using eq_of_mem_uIoc_of_mem_uIoc
 
-lemma eq_of_not_mem_interval_oc_of_not_mem_interval_oc (ha : a ≤ c) (hb : b ≤ c) :
+lemma eq_of_not_mem_uIoc_of_not_mem_uIoc (ha : a ≤ c) (hb : b ≤ c) :
   a ∉ Ι b c → b ∉ Ι a c → a = b :=
-by simp_rw not_mem_interval_oc; rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩); apply le_antisymm;
+by simp_rw not_mem_uIoc; rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩); apply le_antisymm;
     assumption <|> exact le_of_lt ‹_› <|> cases not_le_of_lt ‹_› ‹_›
 
-lemma interval_oc_injective_right (a : α) : injective (λ b, Ι b a) :=
+lemma uIoc_injective_right (a : α) : injective (λ b, Ι b a) :=
 begin
   rintro b c h,
   rw ext_iff at h,
   obtain ha | ha := le_or_lt b a,
   { have hb := (h b).not,
-    simp only [ha, left_mem_interval_oc, not_lt, true_iff, not_mem_interval_oc, ←not_le, and_true,
+    simp only [ha, left_mem_uIoc, not_lt, true_iff, not_mem_uIoc, ←not_le, and_true,
       not_true, false_and, not_false_iff, true_iff, or_false] at hb,
     refine hb.eq_of_not_lt (λ hc, _),
     simpa [ha, and_iff_right hc, ←@not_le _ _ _ a, -not_le] using h c },
-  { refine eq_of_mem_interval_oc_of_mem_interval_oc ((h _).1 $ left_mem_interval_oc.2 ha)
-      ((h _).2 $ left_mem_interval_oc.2 $ ha.trans_le _),
-    simpa [ha, ha.not_le, mem_interval_oc] using h b }
+  { refine eq_of_mem_uIoc_of_mem_uIoc ((h _).1 $ left_mem_uIoc.2 ha)
+      ((h _).2 $ left_mem_uIoc.2 $ ha.trans_le _),
+    simpa [ha, ha.not_le, mem_uIoc] using h b }
 end
 
-lemma interval_oc_injective_left (a : α) : injective (Ι a) :=
-by simpa only [interval_oc_swap] using interval_oc_injective_right a
+lemma uIoc_injective_left (a : α) : injective (Ι a) :=
+by simpa only [uIoc_swap] using uIoc_injective_right a
 
 end linear_order
 end set

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-26-08

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

ab3b6a0f

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou
 -/
 import Order.Bounds.Basic
-import Data.Set.Intervals.Basic
+import Order.Interval.Set.Basic
 
 #align_import data.set.intervals.unordered_interval from "leanprover-community/mathlib"@"3ba15165bd6927679be7c22d6091a87337e3cd0c"

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -355,7 +355,7 @@ theorem monotone_or_antitone_iff_uIcc :
 #align set.monotone_or_antitone_iff_uIcc Set.monotone_or_antitone_iff_uIcc
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
 #print Set.monotoneOn_or_antitoneOn_iff_uIcc /-
 theorem monotoneOn_or_antitoneOn_iff_uIcc :
     MonotoneOn f s ∨ AntitoneOn f s ↔

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -233,7 +233,7 @@ theorem eq_of_mem_uIcc_of_mem_uIcc' : b ∈ [a, c] → c ∈ [a, b] → b = c :=
 #print Set.uIcc_injective_right /-
 theorem uIcc_injective_right (a : α) : Injective fun b => uIcc b a := fun b c h =>
   by
-  rw [ext_iff] at h 
+  rw [ext_iff] at h
   exact eq_of_mem_uIcc_of_mem_uIcc ((h _).1 left_mem_uIcc) ((h _).2 left_mem_uIcc)
 #align set.uIcc_injective_right Set.uIcc_injective_right
 -/
@@ -474,11 +474,11 @@ theorem eq_of_not_mem_uIoc_of_not_mem_uIoc (ha : a ≤ c) (hb : b ≤ c) :
 theorem uIoc_injective_right (a : α) : Injective fun b => Ι b a :=
   by
   rintro b c h
-  rw [ext_iff] at h 
+  rw [ext_iff] at h
   obtain ha | ha := le_or_lt b a
   · have hb := (h b).Not
     simp only [ha, left_mem_uIoc, not_lt, true_iff_iff, not_mem_uIoc, ← not_le, and_true_iff,
-      not_true, false_and_iff, not_false_iff, true_iff_iff, or_false_iff] at hb 
+      not_true, false_and_iff, not_false_iff, true_iff_iff, or_false_iff] at hb
     refine' hb.eq_of_not_lt fun hc => _
     simpa [ha, and_iff_right hc, ← @not_le _ _ _ a, -not_le] using h c
   · refine'

bump to nightly-2023-09-30-06

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

0742bc05

Diff

@@ -254,25 +254,33 @@ section Lattice
 
 variable [Lattice β] {f : α → β} {s : Set α} {a b : α}
 
+#print MonotoneOn.image_uIcc_subset /-
 theorem MonotoneOn.image_uIcc_subset (hf : MonotoneOn f (uIcc a b)) :
     f '' uIcc a b ⊆ uIcc (f a) (f b) :=
   hf.image_Icc_subset.trans <| by
     rw [hf.map_sup left_mem_uIcc right_mem_uIcc, hf.map_inf left_mem_uIcc right_mem_uIcc, uIcc]
 #align monotone_on.image_uIcc_subset MonotoneOn.image_uIcc_subset
+-/
 
+#print AntitoneOn.image_uIcc_subset /-
 theorem AntitoneOn.image_uIcc_subset (hf : AntitoneOn f (uIcc a b)) :
     f '' uIcc a b ⊆ uIcc (f a) (f b) :=
   hf.image_Icc_subset.trans <| by
     rw [hf.map_sup left_mem_uIcc right_mem_uIcc, hf.map_inf left_mem_uIcc right_mem_uIcc, uIcc]
 #align antitone_on.image_uIcc_subset AntitoneOn.image_uIcc_subset
+-/
 
+#print Monotone.image_uIcc_subset /-
 theorem Monotone.image_uIcc_subset (hf : Monotone f) : f '' uIcc a b ⊆ uIcc (f a) (f b) :=
   (hf.MonotoneOn _).image_uIcc_subset
 #align monotone.image_uIcc_subset Monotone.image_uIcc_subset
+-/
 
+#print Antitone.image_uIcc_subset /-
 theorem Antitone.image_uIcc_subset (hf : Antitone f) : f '' uIcc a b ⊆ uIcc (f a) (f b) :=
   (hf.AntitoneOn _).image_uIcc_subset
 #align antitone.image_uIcc_subset Antitone.image_uIcc_subset
+-/
 
 end Lattice

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2020 Zhouhang Zhou. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou
 -/
-import Mathbin.Order.Bounds.Basic
-import Mathbin.Data.Set.Intervals.Basic
+import Order.Bounds.Basic
+import Data.Set.Intervals.Basic
 
 #align_import data.set.intervals.unordered_interval from "leanprover-community/mathlib"@"3ba15165bd6927679be7c22d6091a87337e3cd0c"
 
@@ -347,7 +347,7 @@ theorem monotone_or_antitone_iff_uIcc :
 #align set.monotone_or_antitone_iff_uIcc Set.monotone_or_antitone_iff_uIcc
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
 #print Set.monotoneOn_or_antitoneOn_iff_uIcc /-
 theorem monotoneOn_or_antitoneOn_iff_uIcc :
     MonotoneOn f s ∨ AntitoneOn f s ↔

bump to nightly-2023-08-03-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/48a058d7e39a80ed56858505719a0b2197900999

906749b9

Diff

@@ -6,7 +6,7 @@ Authors: Zhouhang Zhou
 import Mathbin.Order.Bounds.Basic
 import Mathbin.Data.Set.Intervals.Basic
 
-#align_import data.set.intervals.unordered_interval from "leanprover-community/mathlib"@"4020ddee5b4580a409bfda7d2f42726ce86ae674"
+#align_import data.set.intervals.unordered_interval from "leanprover-community/mathlib"@"3ba15165bd6927679be7c22d6091a87337e3cd0c"
 
 /-!
 # Intervals without endpoints ordering
@@ -248,7 +248,35 @@ end DistribLattice
 
 section LinearOrder
 
-variable [LinearOrder α] [LinearOrder β] {f : α → β} {s : Set α} {a a₁ a₂ b b₁ b₂ c d x : α}
+variable [LinearOrder α]
+
+section Lattice
+
+variable [Lattice β] {f : α → β} {s : Set α} {a b : α}
+
+theorem MonotoneOn.image_uIcc_subset (hf : MonotoneOn f (uIcc a b)) :
+    f '' uIcc a b ⊆ uIcc (f a) (f b) :=
+  hf.image_Icc_subset.trans <| by
+    rw [hf.map_sup left_mem_uIcc right_mem_uIcc, hf.map_inf left_mem_uIcc right_mem_uIcc, uIcc]
+#align monotone_on.image_uIcc_subset MonotoneOn.image_uIcc_subset
+
+theorem AntitoneOn.image_uIcc_subset (hf : AntitoneOn f (uIcc a b)) :
+    f '' uIcc a b ⊆ uIcc (f a) (f b) :=
+  hf.image_Icc_subset.trans <| by
+    rw [hf.map_sup left_mem_uIcc right_mem_uIcc, hf.map_inf left_mem_uIcc right_mem_uIcc, uIcc]
+#align antitone_on.image_uIcc_subset AntitoneOn.image_uIcc_subset
+
+theorem Monotone.image_uIcc_subset (hf : Monotone f) : f '' uIcc a b ⊆ uIcc (f a) (f b) :=
+  (hf.MonotoneOn _).image_uIcc_subset
+#align monotone.image_uIcc_subset Monotone.image_uIcc_subset
+
+theorem Antitone.image_uIcc_subset (hf : Antitone f) : f '' uIcc a b ⊆ uIcc (f a) (f b) :=
+  (hf.AntitoneOn _).image_uIcc_subset
+#align antitone.image_uIcc_subset Antitone.image_uIcc_subset
+
+end Lattice
+
+variable [LinearOrder β] {f : α → β} {s : Set α} {a a₁ a₂ b b₁ b₂ c d x : α}
 
 #print Set.Icc_min_max /-
 theorem Icc_min_max : Icc (min a b) (max a b) = [a, b] :=

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Zhouhang Zhou. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou
-
-! This file was ported from Lean 3 source module data.set.intervals.unordered_interval
-! leanprover-community/mathlib commit 4020ddee5b4580a409bfda7d2f42726ce86ae674
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Bounds.Basic
 import Mathbin.Data.Set.Intervals.Basic
 
+#align_import data.set.intervals.unordered_interval from "leanprover-community/mathlib"@"4020ddee5b4580a409bfda7d2f42726ce86ae674"
+
 /-!
 # Intervals without endpoints ordering
 
@@ -322,7 +319,7 @@ theorem monotone_or_antitone_iff_uIcc :
 #align set.monotone_or_antitone_iff_uIcc Set.monotone_or_antitone_iff_uIcc
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
 #print Set.monotoneOn_or_antitoneOn_iff_uIcc /-
 theorem monotoneOn_or_antitoneOn_iff_uIcc :
     MonotoneOn f s ∨ AntitoneOn f s ↔

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -62,7 +62,6 @@ def uIcc (a b : α) : Set α :=
 #align set.uIcc Set.uIcc
 -/
 
--- mathport name: set.uIcc
 scoped[Interval] notation "[" a ", " b "]" => Set.uIcc a b
 
 #print Set.dual_uIcc /-
@@ -170,9 +169,11 @@ theorem uIcc_subset_uIcc_iff_mem : [a₁, b₁] ⊆ [a₂, b₂] ↔ a₁ ∈ [a
 #align set.uIcc_subset_uIcc_iff_mem Set.uIcc_subset_uIcc_iff_mem
 -/
 
+#print Set.uIcc_subset_uIcc_iff_le' /-
 theorem uIcc_subset_uIcc_iff_le' : [a₁, b₁] ⊆ [a₂, b₂] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂ :=
   Icc_subset_Icc_iff inf_le_sup
 #align set.uIcc_subset_uIcc_iff_le' Set.uIcc_subset_uIcc_iff_le'
+-/
 
 #print Set.uIcc_subset_uIcc_right /-
 theorem uIcc_subset_uIcc_right (h : x ∈ [a, b]) : [x, b] ⊆ [a, b] :=
@@ -197,14 +198,18 @@ theorem bdd_below_bdd_above_iff_subset_uIcc (s : Set α) :
 section Prod
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.uIcc_prod_uIcc /-
 @[simp]
 theorem uIcc_prod_uIcc (a₁ a₂ : α) (b₁ b₂ : β) : [a₁, a₂] ×ˢ [b₁, b₂] = [(a₁, b₁), (a₂, b₂)] :=
   Icc_prod_Icc _ _ _ _
 #align set.uIcc_prod_uIcc Set.uIcc_prod_uIcc
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.uIcc_prod_eq /-
 theorem uIcc_prod_eq (a b : α × β) : [a, b] = [a.1, b.1] ×ˢ [a.2, b.2] := by simp
 #align set.uIcc_prod_eq Set.uIcc_prod_eq
+-/
 
 end Prod
 
@@ -248,9 +253,11 @@ section LinearOrder
 
 variable [LinearOrder α] [LinearOrder β] {f : α → β} {s : Set α} {a a₁ a₂ b b₁ b₂ c d x : α}
 
+#print Set.Icc_min_max /-
 theorem Icc_min_max : Icc (min a b) (max a b) = [a, b] :=
   rfl
 #align set.Icc_min_max Set.Icc_min_max
+-/
 
 #print Set.uIcc_of_not_le /-
 theorem uIcc_of_not_le (h : ¬a ≤ b) : [a, b] = Icc b a :=
@@ -264,8 +271,10 @@ theorem uIcc_of_not_ge (h : ¬b ≤ a) : [a, b] = Icc a b :=
 #align set.uIcc_of_not_ge Set.uIcc_of_not_ge
 -/
 
+#print Set.uIcc_eq_union /-
 theorem uIcc_eq_union : [a, b] = Icc a b ∪ Icc b a := by rw [Icc_union_Icc', max_comm] <;> rfl
 #align set.uIcc_eq_union Set.uIcc_eq_union
+-/
 
 #print Set.mem_uIcc /-
 theorem mem_uIcc : a ∈ [b, c] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b := by simp [uIcc_eq_union]
@@ -284,16 +293,21 @@ theorem not_mem_uIcc_of_gt (ha : a < c) (hb : b < c) : c ∉ [a, b] :=
 #align set.not_mem_uIcc_of_gt Set.not_mem_uIcc_of_gt
 -/
 
+#print Set.uIcc_subset_uIcc_iff_le /-
 theorem uIcc_subset_uIcc_iff_le :
     [a₁, b₁] ⊆ [a₂, b₂] ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂ :=
   uIcc_subset_uIcc_iff_le'
 #align set.uIcc_subset_uIcc_iff_le Set.uIcc_subset_uIcc_iff_le
+-/
 
+#print Set.uIcc_subset_uIcc_union_uIcc /-
 /-- A sort of triangle inequality. -/
 theorem uIcc_subset_uIcc_union_uIcc : [a, c] ⊆ [a, b] ∪ [b, c] := fun x => by
   simp only [mem_uIcc, mem_union] <;> cases le_total a c <;> cases le_total x b <;> tauto
 #align set.uIcc_subset_uIcc_union_uIcc Set.uIcc_subset_uIcc_union_uIcc
+-/
 
+#print Set.monotone_or_antitone_iff_uIcc /-
 theorem monotone_or_antitone_iff_uIcc :
     Monotone f ∨ Antitone f ↔ ∀ a b c, c ∈ [a, b] → f c ∈ [f a, f b] :=
   by
@@ -306,14 +320,17 @@ theorem monotone_or_antitone_iff_uIcc :
   · exact ⟨a, c, b, Icc_subset_uIcc ⟨hab, hbc⟩, fun h => h.2.not_lt <| max_lt hfab hfcb⟩
   · exact ⟨a, c, b, Icc_subset_uIcc ⟨hab, hbc⟩, fun h => h.1.not_lt <| lt_min hfba hfbc⟩
 #align set.monotone_or_antitone_iff_uIcc Set.monotone_or_antitone_iff_uIcc
+-/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
+#print Set.monotoneOn_or_antitoneOn_iff_uIcc /-
 theorem monotoneOn_or_antitoneOn_iff_uIcc :
     MonotoneOn f s ∨ AntitoneOn f s ↔
       ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s) (c) (_ : c ∈ s), c ∈ [a, b] → f c ∈ [f a, f b] :=
   by
   simp [monotone_on_iff_monotone, antitone_on_iff_antitone, monotone_or_antitone_iff_uIcc, mem_uIcc]
 #align set.monotone_on_or_antitone_on_iff_uIcc Set.monotoneOn_or_antitoneOn_iff_uIcc
+-/
 
 #print Set.uIoc /-
 /-- The open-closed interval with unordered bounds. -/
@@ -321,7 +338,6 @@ def uIoc : α → α → Set α := fun a b => Ioc (min a b) (max a b)
 #align set.uIoc Set.uIoc
 -/
 
--- mathport name: exprΙ
 -- Below is a capital iota
 scoped[Interval] notation "Ι" => Set.uIoc
 
@@ -337,8 +353,10 @@ theorem uIoc_of_lt (h : b < a) : Ι a b = Ioc b a := by simp [uIoc, h.le]
 #align set.uIoc_of_lt Set.uIoc_of_lt
 -/
 
+#print Set.uIoc_eq_union /-
 theorem uIoc_eq_union : Ι a b = Ioc a b ∪ Ioc b a := by cases le_total a b <;> simp [uIoc, *]
 #align set.uIoc_eq_union Set.uIoc_eq_union
+-/
 
 #print Set.mem_uIoc /-
 theorem mem_uIoc : a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b := by

bump to nightly-2023-06-08-23

mathlib commit https://github.com/leanprover-community/mathlib/commit/31c24aa72e7b3e5ed97a8412470e904f82b81004

d3cfe2e3

Diff

@@ -307,7 +307,7 @@ theorem monotone_or_antitone_iff_uIcc :
   · exact ⟨a, c, b, Icc_subset_uIcc ⟨hab, hbc⟩, fun h => h.1.not_lt <| lt_min hfba hfbc⟩
 #align set.monotone_or_antitone_iff_uIcc Set.monotone_or_antitone_iff_uIcc
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
 theorem monotoneOn_or_antitoneOn_iff_uIcc :
     MonotoneOn f s ∨ AntitoneOn f s ↔
       ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s) (c) (_ : c ∈ s), c ∈ [a, b] → f c ∈ [f a, f b] :=

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -231,7 +231,7 @@ theorem eq_of_mem_uIcc_of_mem_uIcc' : b ∈ [a, c] → c ∈ [a, b] → b = c :=
 #print Set.uIcc_injective_right /-
 theorem uIcc_injective_right (a : α) : Injective fun b => uIcc b a := fun b c h =>
   by
-  rw [ext_iff] at h
+  rw [ext_iff] at h 
   exact eq_of_mem_uIcc_of_mem_uIcc ((h _).1 left_mem_uIcc) ((h _).2 left_mem_uIcc)
 #align set.uIcc_injective_right Set.uIcc_injective_right
 -/
@@ -299,7 +299,7 @@ theorem monotone_or_antitone_iff_uIcc :
   by
   constructor
   · rintro (hf | hf) a b c <;> simp_rw [← Icc_min_max, ← hf.map_min, ← hf.map_max]
-    exacts[fun hc => ⟨hf hc.1, hf hc.2⟩, fun hc => ⟨hf hc.2, hf hc.1⟩]
+    exacts [fun hc => ⟨hf hc.1, hf hc.2⟩, fun hc => ⟨hf hc.2, hf hc.1⟩]
   contrapose!
   rw [not_monotone_not_antitone_iff_exists_le_le]
   rintro ⟨a, b, c, hab, hbc, ⟨hfab, hfcb⟩ | ⟨hfba, hfbc⟩⟩
@@ -395,7 +395,10 @@ theorem Ioc_subset_uIoc' : Ioc a b ⊆ Ι b a :=
 #print Set.eq_of_mem_uIoc_of_mem_uIoc /-
 theorem eq_of_mem_uIoc_of_mem_uIoc : a ∈ Ι b c → b ∈ Ι a c → a = b := by
   simp_rw [mem_uIoc] <;> rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩) <;> apply le_antisymm <;>
-    first |assumption|exact le_of_lt ‹_›|exact le_trans ‹_› (le_of_lt ‹_›)
+    first
+    | assumption
+    | exact le_of_lt ‹_›
+    | exact le_trans ‹_› (le_of_lt ‹_›)
 #align set.eq_of_mem_uIoc_of_mem_uIoc Set.eq_of_mem_uIoc_of_mem_uIoc
 -/
 
@@ -409,7 +412,10 @@ theorem eq_of_mem_uIoc_of_mem_uIoc' : b ∈ Ι a c → c ∈ Ι a b → b = c :=
 theorem eq_of_not_mem_uIoc_of_not_mem_uIoc (ha : a ≤ c) (hb : b ≤ c) :
     a ∉ Ι b c → b ∉ Ι a c → a = b := by
   simp_rw [not_mem_uIoc] <;> rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩) <;> apply le_antisymm <;>
-    first |assumption|exact le_of_lt ‹_›|cases not_le_of_lt ‹_› ‹_›
+    first
+    | assumption
+    | exact le_of_lt ‹_›
+    | cases not_le_of_lt ‹_› ‹_›
 #align set.eq_of_not_mem_uIoc_of_not_mem_uIoc Set.eq_of_not_mem_uIoc_of_not_mem_uIoc
 -/
 
@@ -417,11 +423,11 @@ theorem eq_of_not_mem_uIoc_of_not_mem_uIoc (ha : a ≤ c) (hb : b ≤ c) :
 theorem uIoc_injective_right (a : α) : Injective fun b => Ι b a :=
   by
   rintro b c h
-  rw [ext_iff] at h
+  rw [ext_iff] at h 
   obtain ha | ha := le_or_lt b a
   · have hb := (h b).Not
     simp only [ha, left_mem_uIoc, not_lt, true_iff_iff, not_mem_uIoc, ← not_le, and_true_iff,
-      not_true, false_and_iff, not_false_iff, true_iff_iff, or_false_iff] at hb
+      not_true, false_and_iff, not_false_iff, true_iff_iff, or_false_iff] at hb 
     refine' hb.eq_of_not_lt fun hc => _
     simpa [ha, and_iff_right hc, ← @not_le _ _ _ a, -not_le] using h c
   · refine'

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -72,26 +72,34 @@ theorem dual_uIcc (a b : α) : [toDual a, toDual b] = ofDual ⁻¹' [a, b] :=
 #align set.dual_uIcc Set.dual_uIcc
 -/
 
+#print Set.uIcc_of_le /-
 @[simp]
 theorem uIcc_of_le (h : a ≤ b) : [a, b] = Icc a b := by rw [uIcc, inf_eq_left.2 h, sup_eq_right.2 h]
 #align set.uIcc_of_le Set.uIcc_of_le
+-/
 
+#print Set.uIcc_of_ge /-
 @[simp]
 theorem uIcc_of_ge (h : b ≤ a) : [a, b] = Icc b a := by rw [uIcc, inf_eq_right.2 h, sup_eq_left.2 h]
 #align set.uIcc_of_ge Set.uIcc_of_ge
+-/
 
 #print Set.uIcc_comm /-
 theorem uIcc_comm (a b : α) : [a, b] = [b, a] := by simp_rw [uIcc, inf_comm, sup_comm]
 #align set.uIcc_comm Set.uIcc_comm
 -/
 
+#print Set.uIcc_of_lt /-
 theorem uIcc_of_lt (h : a < b) : [a, b] = Icc a b :=
   uIcc_of_le h.le
 #align set.uIcc_of_lt Set.uIcc_of_lt
+-/
 
+#print Set.uIcc_of_gt /-
 theorem uIcc_of_gt (h : b < a) : [a, b] = Icc b a :=
   uIcc_of_ge h.le
 #align set.uIcc_of_gt Set.uIcc_of_gt
+-/
 
 #print Set.uIcc_self /-
 @[simp]
@@ -132,13 +140,17 @@ theorem right_mem_uIcc : b ∈ [a, b] :=
 #align set.right_mem_uIcc Set.right_mem_uIcc
 -/
 
+#print Set.mem_uIcc_of_le /-
 theorem mem_uIcc_of_le (ha : a ≤ x) (hb : x ≤ b) : x ∈ [a, b] :=
   Icc_subset_uIcc ⟨ha, hb⟩
 #align set.mem_uIcc_of_le Set.mem_uIcc_of_le
+-/
 
+#print Set.mem_uIcc_of_ge /-
 theorem mem_uIcc_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [a, b] :=
   Icc_subset_uIcc' ⟨hb, ha⟩
 #align set.mem_uIcc_of_ge Set.mem_uIcc_of_ge
+-/
 
 #print Set.uIcc_subset_uIcc /-
 theorem uIcc_subset_uIcc (h₁ : a₁ ∈ [a₂, b₂]) (h₂ : b₁ ∈ [a₂, b₂]) : [a₁, b₁] ⊆ [a₂, b₂] :=
@@ -198,7 +210,7 @@ end Prod
 
 end Lattice
 
-open Interval
+open scoped Interval
 
 section DistribLattice
 
@@ -240,27 +252,37 @@ theorem Icc_min_max : Icc (min a b) (max a b) = [a, b] :=
   rfl
 #align set.Icc_min_max Set.Icc_min_max
 
+#print Set.uIcc_of_not_le /-
 theorem uIcc_of_not_le (h : ¬a ≤ b) : [a, b] = Icc b a :=
   uIcc_of_gt <| lt_of_not_ge h
 #align set.uIcc_of_not_le Set.uIcc_of_not_le
+-/
 
+#print Set.uIcc_of_not_ge /-
 theorem uIcc_of_not_ge (h : ¬b ≤ a) : [a, b] = Icc a b :=
   uIcc_of_lt <| lt_of_not_ge h
 #align set.uIcc_of_not_ge Set.uIcc_of_not_ge
+-/
 
 theorem uIcc_eq_union : [a, b] = Icc a b ∪ Icc b a := by rw [Icc_union_Icc', max_comm] <;> rfl
 #align set.uIcc_eq_union Set.uIcc_eq_union
 
+#print Set.mem_uIcc /-
 theorem mem_uIcc : a ∈ [b, c] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b := by simp [uIcc_eq_union]
 #align set.mem_uIcc Set.mem_uIcc
+-/
 
+#print Set.not_mem_uIcc_of_lt /-
 theorem not_mem_uIcc_of_lt (ha : c < a) (hb : c < b) : c ∉ [a, b] :=
   not_mem_Icc_of_lt <| lt_min_iff.mpr ⟨ha, hb⟩
 #align set.not_mem_uIcc_of_lt Set.not_mem_uIcc_of_lt
+-/
 
+#print Set.not_mem_uIcc_of_gt /-
 theorem not_mem_uIcc_of_gt (ha : a < c) (hb : b < c) : c ∉ [a, b] :=
   not_mem_Icc_of_gt <| max_lt_iff.mpr ⟨ha, hb⟩
 #align set.not_mem_uIcc_of_gt Set.not_mem_uIcc_of_gt
+-/
 
 theorem uIcc_subset_uIcc_iff_le :
     [a₁, b₁] ⊆ [a₂, b₂] ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂ :=
@@ -303,32 +325,44 @@ def uIoc : α → α → Set α := fun a b => Ioc (min a b) (max a b)
 -- Below is a capital iota
 scoped[Interval] notation "Ι" => Set.uIoc
 
+#print Set.uIoc_of_le /-
 @[simp]
 theorem uIoc_of_le (h : a ≤ b) : Ι a b = Ioc a b := by simp [uIoc, h]
 #align set.uIoc_of_le Set.uIoc_of_le
+-/
 
+#print Set.uIoc_of_lt /-
 @[simp]
 theorem uIoc_of_lt (h : b < a) : Ι a b = Ioc b a := by simp [uIoc, h.le]
 #align set.uIoc_of_lt Set.uIoc_of_lt
+-/
 
 theorem uIoc_eq_union : Ι a b = Ioc a b ∪ Ioc b a := by cases le_total a b <;> simp [uIoc, *]
 #align set.uIoc_eq_union Set.uIoc_eq_union
 
+#print Set.mem_uIoc /-
 theorem mem_uIoc : a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b := by
   simp only [uIoc_eq_union, mem_union, mem_Ioc]
 #align set.mem_uIoc Set.mem_uIoc
+-/
 
+#print Set.not_mem_uIoc /-
 theorem not_mem_uIoc : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a := by
   simp only [uIoc_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]; tauto
 #align set.not_mem_uIoc Set.not_mem_uIoc
+-/
 
+#print Set.left_mem_uIoc /-
 @[simp]
 theorem left_mem_uIoc : a ∈ Ι a b ↔ b < a := by simp [mem_uIoc]
 #align set.left_mem_uIoc Set.left_mem_uIoc
+-/
 
+#print Set.right_mem_uIoc /-
 @[simp]
 theorem right_mem_uIoc : b ∈ Ι a b ↔ a < b := by simp [mem_uIoc]
 #align set.right_mem_uIoc Set.right_mem_uIoc
+-/
 
 #print Set.forall_uIoc_iff /-
 theorem forall_uIoc_iff {P : α → Prop} :
@@ -371,11 +405,13 @@ theorem eq_of_mem_uIoc_of_mem_uIoc' : b ∈ Ι a c → c ∈ Ι a b → b = c :=
 #align set.eq_of_mem_uIoc_of_mem_uIoc' Set.eq_of_mem_uIoc_of_mem_uIoc'
 -/
 
+#print Set.eq_of_not_mem_uIoc_of_not_mem_uIoc /-
 theorem eq_of_not_mem_uIoc_of_not_mem_uIoc (ha : a ≤ c) (hb : b ≤ c) :
     a ∉ Ι b c → b ∉ Ι a c → a = b := by
   simp_rw [not_mem_uIoc] <;> rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩) <;> apply le_antisymm <;>
     first |assumption|exact le_of_lt ‹_›|cases not_le_of_lt ‹_› ‹_›
 #align set.eq_of_not_mem_uIoc_of_not_mem_uIoc Set.eq_of_not_mem_uIoc_of_not_mem_uIoc
+-/
 
 #print Set.uIoc_injective_right /-
 theorem uIoc_injective_right (a : α) : Injective fun b => Ι b a :=

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -72,22 +72,10 @@ theorem dual_uIcc (a b : α) : [toDual a, toDual b] = ofDual ⁻¹' [a, b] :=
 #align set.dual_uIcc Set.dual_uIcc
 -/
 
-/- warning: set.uIcc_of_le -> Set.uIcc_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) a b))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_of_le Set.uIcc_of_leₓ'. -/
 @[simp]
 theorem uIcc_of_le (h : a ≤ b) : [a, b] = Icc a b := by rw [uIcc, inf_eq_left.2 h, sup_eq_right.2 h]
 #align set.uIcc_of_le Set.uIcc_of_le
 
-/- warning: set.uIcc_of_ge -> Set.uIcc_of_ge is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) b a))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_of_ge Set.uIcc_of_geₓ'. -/
 @[simp]
 theorem uIcc_of_ge (h : b ≤ a) : [a, b] = Icc b a := by rw [uIcc, inf_eq_right.2 h, sup_eq_left.2 h]
 #align set.uIcc_of_ge Set.uIcc_of_ge
@@ -97,22 +85,10 @@ theorem uIcc_comm (a b : α) : [a, b] = [b, a] := by simp_rw [uIcc, inf_comm, su
 #align set.uIcc_comm Set.uIcc_comm
 -/
 
-/- warning: set.uIcc_of_lt -> Set.uIcc_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) a b))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_of_lt Set.uIcc_of_ltₓ'. -/
 theorem uIcc_of_lt (h : a < b) : [a, b] = Icc a b :=
   uIcc_of_le h.le
 #align set.uIcc_of_lt Set.uIcc_of_lt
 
-/- warning: set.uIcc_of_gt -> Set.uIcc_of_gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) b a))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_of_gt Set.uIcc_of_gtₓ'. -/
 theorem uIcc_of_gt (h : b < a) : [a, b] = Icc b a :=
   uIcc_of_ge h.le
 #align set.uIcc_of_gt Set.uIcc_of_gt
@@ -156,22 +132,10 @@ theorem right_mem_uIcc : b ∈ [a, b] :=
 #align set.right_mem_uIcc Set.right_mem_uIcc
 -/
 
-/- warning: set.mem_uIcc_of_le -> Set.mem_uIcc_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α} {x : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a x) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) x b) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Set.uIcc.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α} {x : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a x) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) x b) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Set.uIcc.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align set.mem_uIcc_of_le Set.mem_uIcc_of_leₓ'. -/
 theorem mem_uIcc_of_le (ha : a ≤ x) (hb : x ≤ b) : x ∈ [a, b] :=
   Icc_subset_uIcc ⟨ha, hb⟩
 #align set.mem_uIcc_of_le Set.mem_uIcc_of_le
 
-/- warning: set.mem_uIcc_of_ge -> Set.mem_uIcc_of_ge is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α} {x : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b x) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) x a) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Set.uIcc.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α} {x : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b x) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) x a) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Set.uIcc.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align set.mem_uIcc_of_ge Set.mem_uIcc_of_geₓ'. -/
 theorem mem_uIcc_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [a, b] :=
   Icc_subset_uIcc' ⟨hb, ha⟩
 #align set.mem_uIcc_of_ge Set.mem_uIcc_of_ge
@@ -194,12 +158,6 @@ theorem uIcc_subset_uIcc_iff_mem : [a₁, b₁] ⊆ [a₂, b₂] ↔ a₁ ∈ [a
 #align set.uIcc_subset_uIcc_iff_mem Set.uIcc_subset_uIcc_iff_mem
 -/
 
-/- warning: set.uIcc_subset_uIcc_iff_le' -> Set.uIcc_subset_uIcc_iff_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.uIcc.{u1} α _inst_1 a₁ b₁) (Set.uIcc.{u1} α _inst_1 a₂ b₂)) (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)) a₂ b₂) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)) a₁ b₁)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₁ b₁) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₂ b₂)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.uIcc.{u1} α _inst_1 a₁ b₁) (Set.uIcc.{u1} α _inst_1 a₂ b₂)) (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Inf.inf.{u1} α (Lattice.toInf.{u1} α _inst_1) a₂ b₂) (Inf.inf.{u1} α (Lattice.toInf.{u1} α _inst_1) a₁ b₁)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₁ b₁) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₂ b₂)))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_subset_uIcc_iff_le' Set.uIcc_subset_uIcc_iff_le'ₓ'. -/
 theorem uIcc_subset_uIcc_iff_le' : [a₁, b₁] ⊆ [a₂, b₂] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂ :=
   Icc_subset_Icc_iff inf_le_sup
 #align set.uIcc_subset_uIcc_iff_le' Set.uIcc_subset_uIcc_iff_le'
@@ -226,24 +184,12 @@ theorem bdd_below_bdd_above_iff_subset_uIcc (s : Set α) :
 
 section Prod
 
-/- warning: set.uIcc_prod_uIcc -> Set.uIcc_prod_uIcc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Lattice.{u1} α] [_inst_2 : Lattice.{u2} β] (a₁ : α) (a₂ : α) (b₁ : β) (b₂ : β), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β (Set.uIcc.{u1} α _inst_1 a₁ a₂) (Set.uIcc.{u2} β _inst_2 b₁ b₂)) (Set.uIcc.{max u1 u2} (Prod.{u1, u2} α β) (Prod.lattice.{u1, u2} α β _inst_1 _inst_2) (Prod.mk.{u1, u2} α β a₁ b₁) (Prod.mk.{u1, u2} α β a₂ b₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Lattice.{u2} α] [_inst_2 : Lattice.{u1} β] (a₁ : α) (a₂ : α) (b₁ : β) (b₂ : β), Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β (Set.uIcc.{u2} α _inst_1 a₁ a₂) (Set.uIcc.{u1} β _inst_2 b₁ b₂)) (Set.uIcc.{max u1 u2} (Prod.{u2, u1} α β) (Prod.lattice.{u2, u1} α β _inst_1 _inst_2) (Prod.mk.{u2, u1} α β a₁ b₁) (Prod.mk.{u2, u1} α β a₂ b₂))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_prod_uIcc Set.uIcc_prod_uIccₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem uIcc_prod_uIcc (a₁ a₂ : α) (b₁ b₂ : β) : [a₁, a₂] ×ˢ [b₁, b₂] = [(a₁, b₁), (a₂, b₂)] :=
   Icc_prod_Icc _ _ _ _
 #align set.uIcc_prod_uIcc Set.uIcc_prod_uIcc
 
-/- warning: set.uIcc_prod_eq -> Set.uIcc_prod_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Lattice.{u1} α] [_inst_2 : Lattice.{u2} β] (a : Prod.{u1, u2} α β) (b : Prod.{u1, u2} α β), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.uIcc.{max u1 u2} (Prod.{u1, u2} α β) (Prod.lattice.{u1, u2} α β _inst_1 _inst_2) a b) (Set.prod.{u1, u2} α β (Set.uIcc.{u1} α _inst_1 (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (Set.uIcc.{u2} β _inst_2 (Prod.snd.{u1, u2} α β a) (Prod.snd.{u1, u2} α β b)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Lattice.{u2} α] [_inst_2 : Lattice.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (Prod.{u2, u1} α β)) (Set.uIcc.{max u2 u1} (Prod.{u2, u1} α β) (Prod.lattice.{u2, u1} α β _inst_1 _inst_2) a b) (Set.prod.{u2, u1} α β (Set.uIcc.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (Set.uIcc.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b)))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_prod_eq Set.uIcc_prod_eqₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem uIcc_prod_eq (a b : α × β) : [a, b] = [a.1, b.1] ×ˢ [a.2, b.2] := by simp
 #align set.uIcc_prod_eq Set.uIcc_prod_eq
@@ -290,102 +236,42 @@ section LinearOrder
 
 variable [LinearOrder α] [LinearOrder β] {f : α → β} {s : Set α} {a a₁ a₂ b b₁ b₂ c d x : α}
 
-/- warning: set.Icc_min_max -> Set.Icc_min_max is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (Set.Icc.{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)) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (Set.Icc.{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)) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b)
-Case conversion may be inaccurate. Consider using '#align set.Icc_min_max Set.Icc_min_maxₓ'. -/
 theorem Icc_min_max : Icc (min a b) (max a b) = [a, b] :=
   rfl
 #align set.Icc_min_max Set.Icc_min_max
 
-/- warning: set.uIcc_of_not_le -> Set.uIcc_of_not_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (Not (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (Not (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) b a))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_of_not_le Set.uIcc_of_not_leₓ'. -/
 theorem uIcc_of_not_le (h : ¬a ≤ b) : [a, b] = Icc b a :=
   uIcc_of_gt <| lt_of_not_ge h
 #align set.uIcc_of_not_le Set.uIcc_of_not_le
 
-/- warning: set.uIcc_of_not_ge -> Set.uIcc_of_not_ge is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (Not (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (Not (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) a b))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_of_not_ge Set.uIcc_of_not_geₓ'. -/
 theorem uIcc_of_not_ge (h : ¬b ≤ a) : [a, b] = Icc a b :=
   uIcc_of_lt <| lt_of_not_ge h
 #align set.uIcc_of_not_ge Set.uIcc_of_not_ge
 
-/- warning: set.uIcc_eq_union -> Set.uIcc_eq_union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) b a))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_eq_union Set.uIcc_eq_unionₓ'. -/
 theorem uIcc_eq_union : [a, b] = Icc a b ∪ Icc b a := by rw [Icc_union_Icc', max_comm] <;> rfl
 #align set.uIcc_eq_union Set.uIcc_eq_union
 
-/- warning: set.mem_uIcc -> Set.mem_uIcc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) b c)) (Or (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a c)) (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c a) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) b c)) (Or (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c)) (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c a) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)))
-Case conversion may be inaccurate. Consider using '#align set.mem_uIcc Set.mem_uIccₓ'. -/
 theorem mem_uIcc : a ∈ [b, c] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b := by simp [uIcc_eq_union]
 #align set.mem_uIcc Set.mem_uIcc
 
-/- warning: set.not_mem_uIcc_of_lt -> Set.not_mem_uIcc_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c b) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c b) -> (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b)))
-Case conversion may be inaccurate. Consider using '#align set.not_mem_uIcc_of_lt Set.not_mem_uIcc_of_ltₓ'. -/
 theorem not_mem_uIcc_of_lt (ha : c < a) (hb : c < b) : c ∉ [a, b] :=
   not_mem_Icc_of_lt <| lt_min_iff.mpr ⟨ha, hb⟩
 #align set.not_mem_uIcc_of_lt Set.not_mem_uIcc_of_lt
 
-/- warning: set.not_mem_uIcc_of_gt -> Set.not_mem_uIcc_of_gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b c) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b c) -> (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b)))
-Case conversion may be inaccurate. Consider using '#align set.not_mem_uIcc_of_gt Set.not_mem_uIcc_of_gtₓ'. -/
 theorem not_mem_uIcc_of_gt (ha : a < c) (hb : b < c) : c ∉ [a, b] :=
   not_mem_Icc_of_gt <| max_lt_iff.mpr ⟨ha, hb⟩
 #align set.not_mem_uIcc_of_gt Set.not_mem_uIcc_of_gt
 
-/- warning: set.uIcc_subset_uIcc_iff_le -> Set.uIcc_subset_uIcc_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a₁ b₁) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a₂ b₂)) (And (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.min.{u1} α _inst_1 a₁ b₁)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.max.{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 (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a₁ b₁) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a₂ b₂)) (And (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₂) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a₁ b₁)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a₁ b₁) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a₂ b₂)))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_subset_uIcc_iff_le Set.uIcc_subset_uIcc_iff_leₓ'. -/
 theorem uIcc_subset_uIcc_iff_le :
     [a₁, b₁] ⊆ [a₂, b₂] ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂ :=
   uIcc_subset_uIcc_iff_le'
 #align set.uIcc_subset_uIcc_iff_le Set.uIcc_subset_uIcc_iff_le
 
-/- warning: set.uIcc_subset_uIcc_union_uIcc -> Set.uIcc_subset_uIcc_union_uIcc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a c) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a c) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) b c))
-Case conversion may be inaccurate. Consider using '#align set.uIcc_subset_uIcc_union_uIcc Set.uIcc_subset_uIcc_union_uIccₓ'. -/
 /-- A sort of triangle inequality. -/
 theorem uIcc_subset_uIcc_union_uIcc : [a, c] ⊆ [a, b] ∪ [b, c] := fun x => by
   simp only [mem_uIcc, mem_union] <;> cases le_total a c <;> cases le_total x b <;> tauto
 #align set.uIcc_subset_uIcc_union_uIcc Set.uIcc_subset_uIcc_union_uIcc
 
-/- warning: set.monotone_or_antitone_iff_uIcc -> Set.monotone_or_antitone_iff_uIcc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β}, Iff (Or (Monotone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) f) (Antitone.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) f)) (forall (a : α) (b : α) (c : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b)) -> (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (f c) (Set.uIcc.{u2} β (LinearOrder.toLattice.{u2} β _inst_2) (f a) (f b))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LinearOrder.{u2} α] [_inst_2 : LinearOrder.{u1} β] {f : α -> β}, Iff (Or (Monotone.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) f) (Antitone.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) f)) (forall (a : α) (b : α) (c : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) c (Set.uIcc.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)) a b)) -> (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (f c) (Set.uIcc.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2)) (f a) (f b))))
-Case conversion may be inaccurate. Consider using '#align set.monotone_or_antitone_iff_uIcc Set.monotone_or_antitone_iff_uIccₓ'. -/
 theorem monotone_or_antitone_iff_uIcc :
     Monotone f ∨ Antitone f ↔ ∀ a b c, c ∈ [a, b] → f c ∈ [f a, f b] :=
   by
@@ -399,12 +285,6 @@ theorem monotone_or_antitone_iff_uIcc :
   · exact ⟨a, c, b, Icc_subset_uIcc ⟨hab, hbc⟩, fun h => h.1.not_lt <| lt_min hfba hfbc⟩
 #align set.monotone_or_antitone_iff_uIcc Set.monotone_or_antitone_iff_uIcc
 
-/- warning: set.monotone_on_or_antitone_on_iff_uIcc -> Set.monotoneOn_or_antitoneOn_iff_uIcc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : LinearOrder.{u2} β] {f : α -> β} {s : Set.{u1} α}, Iff (Or (MonotoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) f s) (AntitoneOn.{u1, u2} α β (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u2} β (SemilatticeInf.toPartialOrder.{u2} β (Lattice.toSemilatticeInf.{u2} β (LinearOrder.toLattice.{u2} β _inst_2)))) f s)) (forall (a : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (forall (c : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b)) -> (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (f c) (Set.uIcc.{u2} β (LinearOrder.toLattice.{u2} β _inst_2) (f a) (f b))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LinearOrder.{u2} α] [_inst_2 : LinearOrder.{u1} β] {f : α -> β} {s : Set.{u2} α}, Iff (Or (MonotoneOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) f s) (AntitoneOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) f s)) (forall (a : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s) -> (forall (b : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) b s) -> (forall (c : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) c s) -> (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) c (Set.uIcc.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)) a b)) -> (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (f c) (Set.uIcc.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2)) (f a) (f b))))))
-Case conversion may be inaccurate. Consider using '#align set.monotone_on_or_antitone_on_iff_uIcc Set.monotoneOn_or_antitoneOn_iff_uIccₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
 theorem monotoneOn_or_antitoneOn_iff_uIcc :
     MonotoneOn f s ∨ AntitoneOn f s ↔
@@ -423,71 +303,29 @@ def uIoc : α → α → Set α := fun a b => Ioc (min a b) (max a b)
 -- Below is a capital iota
 scoped[Interval] notation "Ι" => Set.uIoc
 
-/- warning: set.uIoc_of_le -> Set.uIoc_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIoc.{u1} α _inst_1 a b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIoc.{u1} α _inst_1 a b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) a b))
-Case conversion may be inaccurate. Consider using '#align set.uIoc_of_le Set.uIoc_of_leₓ'. -/
 @[simp]
 theorem uIoc_of_le (h : a ≤ b) : Ι a b = Ioc a b := by simp [uIoc, h]
 #align set.uIoc_of_le Set.uIoc_of_le
 
-/- warning: set.uIoc_of_lt -> Set.uIoc_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIoc.{u1} α _inst_1 a b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIoc.{u1} α _inst_1 a b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) b a))
-Case conversion may be inaccurate. Consider using '#align set.uIoc_of_lt Set.uIoc_of_ltₓ'. -/
 @[simp]
 theorem uIoc_of_lt (h : b < a) : Ι a b = Ioc b a := by simp [uIoc, h.le]
 #align set.uIoc_of_lt Set.uIoc_of_lt
 
-/- warning: set.uIoc_eq_union -> Set.uIoc_eq_union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (Set.uIoc.{u1} α _inst_1 a b) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Eq.{succ u1} (Set.{u1} α) (Set.uIoc.{u1} α _inst_1 a b) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) a b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) b a))
-Case conversion may be inaccurate. Consider using '#align set.uIoc_eq_union Set.uIoc_eq_unionₓ'. -/
 theorem uIoc_eq_union : Ι a b = Ioc a b ∪ Ioc b a := by cases le_total a b <;> simp [uIoc, *]
 #align set.uIoc_eq_union Set.uIoc_eq_union
 
-/- warning: set.mem_uIoc -> Set.mem_uIoc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c)) (Or (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a c)) (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c a) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c)) (Or (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c)) (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c a) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)))
-Case conversion may be inaccurate. Consider using '#align set.mem_uIoc Set.mem_uIocₓ'. -/
 theorem mem_uIoc : a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b := by
   simp only [uIoc_eq_union, mem_union, mem_Ioc]
 #align set.mem_uIoc Set.mem_uIoc
 
-/- warning: set.not_mem_uIoc -> Set.not_mem_uIoc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c))) (Or (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a c)) (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c a) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c))) (Or (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c)) (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c a) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a)))
-Case conversion may be inaccurate. Consider using '#align set.not_mem_uIoc Set.not_mem_uIocₓ'. -/
 theorem not_mem_uIoc : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a := by
   simp only [uIoc_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]; tauto
 #align set.not_mem_uIoc Set.not_mem_uIoc
 
-/- warning: set.left_mem_uIoc -> Set.left_mem_uIoc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.uIoc.{u1} α _inst_1 a b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIoc.{u1} α _inst_1 a b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a)
-Case conversion may be inaccurate. Consider using '#align set.left_mem_uIoc Set.left_mem_uIocₓ'. -/
 @[simp]
 theorem left_mem_uIoc : a ∈ Ι a b ↔ b < a := by simp [mem_uIoc]
 #align set.left_mem_uIoc Set.left_mem_uIoc
 
-/- warning: set.right_mem_uIoc -> Set.right_mem_uIoc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b (Set.uIoc.{u1} α _inst_1 a b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b (Set.uIoc.{u1} α _inst_1 a b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)
-Case conversion may be inaccurate. Consider using '#align set.right_mem_uIoc Set.right_mem_uIocₓ'. -/
 @[simp]
 theorem right_mem_uIoc : b ∈ Ι a b ↔ a < b := by simp [mem_uIoc]
 #align set.right_mem_uIoc Set.right_mem_uIoc
@@ -533,12 +371,6 @@ theorem eq_of_mem_uIoc_of_mem_uIoc' : b ∈ Ι a c → c ∈ Ι a b → b = c :=
 #align set.eq_of_mem_uIoc_of_mem_uIoc' Set.eq_of_mem_uIoc_of_mem_uIoc'
 -/
 
-/- warning: set.eq_of_not_mem_uIoc_of_not_mem_uIoc -> Set.eq_of_not_mem_uIoc_of_not_mem_uIoc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b c) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c))) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b (Set.uIoc.{u1} α _inst_1 a c))) -> (Eq.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b c) -> (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c))) -> (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b (Set.uIoc.{u1} α _inst_1 a c))) -> (Eq.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align set.eq_of_not_mem_uIoc_of_not_mem_uIoc Set.eq_of_not_mem_uIoc_of_not_mem_uIocₓ'. -/
 theorem eq_of_not_mem_uIoc_of_not_mem_uIoc (ha : a ≤ c) (hb : b ≤ c) :
     a ∉ Ι b c → b ∉ Ι a c → a = b := by
   simp_rw [not_mem_uIoc] <;> rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩) <;> apply le_antisymm <;>

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -468,10 +468,8 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c))) (Or (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c)) (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c a) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a)))
 Case conversion may be inaccurate. Consider using '#align set.not_mem_uIoc Set.not_mem_uIocₓ'. -/
-theorem not_mem_uIoc : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a :=
-  by
-  simp only [uIoc_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]
-  tauto
+theorem not_mem_uIoc : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a := by
+  simp only [uIoc_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]; tauto
 #align set.not_mem_uIoc Set.not_mem_uIoc
 
 /- warning: set.left_mem_uIoc -> Set.left_mem_uIoc is a dubious translation:

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -72,34 +72,50 @@ theorem dual_uIcc (a b : α) : [toDual a, toDual b] = ofDual ⁻¹' [a, b] :=
 #align set.dual_uIcc Set.dual_uIcc
 -/
 
-#print Set.uIcc_of_le /-
+/- warning: set.uIcc_of_le -> Set.uIcc_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) a b))
+Case conversion may be inaccurate. Consider using '#align set.uIcc_of_le Set.uIcc_of_leₓ'. -/
 @[simp]
 theorem uIcc_of_le (h : a ≤ b) : [a, b] = Icc a b := by rw [uIcc, inf_eq_left.2 h, sup_eq_right.2 h]
 #align set.uIcc_of_le Set.uIcc_of_le
--/
 
-#print Set.uIcc_of_ge /-
+/- warning: set.uIcc_of_ge -> Set.uIcc_of_ge is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) b a))
+Case conversion may be inaccurate. Consider using '#align set.uIcc_of_ge Set.uIcc_of_geₓ'. -/
 @[simp]
 theorem uIcc_of_ge (h : b ≤ a) : [a, b] = Icc b a := by rw [uIcc, inf_eq_right.2 h, sup_eq_left.2 h]
 #align set.uIcc_of_ge Set.uIcc_of_ge
--/
 
 #print Set.uIcc_comm /-
 theorem uIcc_comm (a b : α) : [a, b] = [b, a] := by simp_rw [uIcc, inf_comm, sup_comm]
 #align set.uIcc_comm Set.uIcc_comm
 -/
 
-#print Set.uIcc_of_lt /-
+/- warning: set.uIcc_of_lt -> Set.uIcc_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) a b))
+Case conversion may be inaccurate. Consider using '#align set.uIcc_of_lt Set.uIcc_of_ltₓ'. -/
 theorem uIcc_of_lt (h : a < b) : [a, b] = Icc a b :=
   uIcc_of_le h.le
 #align set.uIcc_of_lt Set.uIcc_of_lt
--/
 
-#print Set.uIcc_of_gt /-
+/- warning: set.uIcc_of_gt -> Set.uIcc_of_gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α _inst_1 a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1))) b a))
+Case conversion may be inaccurate. Consider using '#align set.uIcc_of_gt Set.uIcc_of_gtₓ'. -/
 theorem uIcc_of_gt (h : b < a) : [a, b] = Icc b a :=
   uIcc_of_ge h.le
 #align set.uIcc_of_gt Set.uIcc_of_gt
--/
 
 #print Set.uIcc_self /-
 @[simp]
@@ -140,17 +156,25 @@ theorem right_mem_uIcc : b ∈ [a, b] :=
 #align set.right_mem_uIcc Set.right_mem_uIcc
 -/
 
-#print Set.mem_uIcc_of_le /-
+/- warning: set.mem_uIcc_of_le -> Set.mem_uIcc_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α} {x : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a x) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) x b) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Set.uIcc.{u1} α _inst_1 a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α} {x : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) a x) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) x b) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Set.uIcc.{u1} α _inst_1 a b))
+Case conversion may be inaccurate. Consider using '#align set.mem_uIcc_of_le Set.mem_uIcc_of_leₓ'. -/
 theorem mem_uIcc_of_le (ha : a ≤ x) (hb : x ≤ b) : x ∈ [a, b] :=
   Icc_subset_uIcc ⟨ha, hb⟩
 #align set.mem_uIcc_of_le Set.mem_uIcc_of_le
--/
 
-#print Set.mem_uIcc_of_ge /-
+/- warning: set.mem_uIcc_of_ge -> Set.mem_uIcc_of_ge is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α} {x : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b x) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) x a) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x (Set.uIcc.{u1} α _inst_1 a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a : α} {b : α} {x : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) b x) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) x a) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x (Set.uIcc.{u1} α _inst_1 a b))
+Case conversion may be inaccurate. Consider using '#align set.mem_uIcc_of_ge Set.mem_uIcc_of_geₓ'. -/
 theorem mem_uIcc_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [a, b] :=
   Icc_subset_uIcc' ⟨hb, ha⟩
 #align set.mem_uIcc_of_ge Set.mem_uIcc_of_ge
--/
 
 #print Set.uIcc_subset_uIcc /-
 theorem uIcc_subset_uIcc (h₁ : a₁ ∈ [a₂, b₂]) (h₂ : b₁ ∈ [a₂, b₂]) : [a₁, b₁] ⊆ [a₂, b₂] :=
@@ -172,7 +196,7 @@ theorem uIcc_subset_uIcc_iff_mem : [a₁, b₁] ⊆ [a₂, b₂] ↔ a₁ ∈ [a
 
 /- warning: set.uIcc_subset_uIcc_iff_le' -> Set.uIcc_subset_uIcc_iff_le' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.uIcc.{u1} α _inst_1 a₁ b₁) (Set.uIcc.{u1} α _inst_1 a₂ b₂)) (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)) a₂ b₂) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)) a₁ b₁)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₁ b₁) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₂ b₂)))
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.uIcc.{u1} α _inst_1 a₁ b₁) (Set.uIcc.{u1} α _inst_1 a₂ b₂)) (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)) a₂ b₂) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)) a₁ b₁)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₁ b₁) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₂ b₂)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.uIcc.{u1} α _inst_1 a₁ b₁) (Set.uIcc.{u1} α _inst_1 a₂ b₂)) (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Inf.inf.{u1} α (Lattice.toInf.{u1} α _inst_1) a₂ b₂) (Inf.inf.{u1} α (Lattice.toInf.{u1} α _inst_1) a₁ b₁)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₁ b₁) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₂ b₂)))
 Case conversion may be inaccurate. Consider using '#align set.uIcc_subset_uIcc_iff_le' Set.uIcc_subset_uIcc_iff_le'ₓ'. -/
@@ -276,17 +300,25 @@ theorem Icc_min_max : Icc (min a b) (max a b) = [a, b] :=
   rfl
 #align set.Icc_min_max Set.Icc_min_max
 
-#print Set.uIcc_of_not_le /-
+/- warning: set.uIcc_of_not_le -> Set.uIcc_of_not_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (Not (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (Not (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) b a))
+Case conversion may be inaccurate. Consider using '#align set.uIcc_of_not_le Set.uIcc_of_not_leₓ'. -/
 theorem uIcc_of_not_le (h : ¬a ≤ b) : [a, b] = Icc b a :=
   uIcc_of_gt <| lt_of_not_ge h
 #align set.uIcc_of_not_le Set.uIcc_of_not_le
--/
 
-#print Set.uIcc_of_not_ge /-
+/- warning: set.uIcc_of_not_ge -> Set.uIcc_of_not_ge is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (Not (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (Not (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) a b))
+Case conversion may be inaccurate. Consider using '#align set.uIcc_of_not_ge Set.uIcc_of_not_geₓ'. -/
 theorem uIcc_of_not_ge (h : ¬b ≤ a) : [a, b] = Icc a b :=
   uIcc_of_lt <| lt_of_not_ge h
 #align set.uIcc_of_not_ge Set.uIcc_of_not_ge
--/
 
 /- warning: set.uIcc_eq_union -> Set.uIcc_eq_union is a dubious translation:
 lean 3 declaration is
@@ -297,26 +329,38 @@ Case conversion may be inaccurate. Consider using '#align set.uIcc_eq_union Set.
 theorem uIcc_eq_union : [a, b] = Icc a b ∪ Icc b a := by rw [Icc_union_Icc', max_comm] <;> rfl
 #align set.uIcc_eq_union Set.uIcc_eq_union
 
-#print Set.mem_uIcc /-
+/- warning: set.mem_uIcc -> Set.mem_uIcc is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) b c)) (Or (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a c)) (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c a) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) b c)) (Or (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c)) (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c a) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)))
+Case conversion may be inaccurate. Consider using '#align set.mem_uIcc Set.mem_uIccₓ'. -/
 theorem mem_uIcc : a ∈ [b, c] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b := by simp [uIcc_eq_union]
 #align set.mem_uIcc Set.mem_uIcc
--/
 
-#print Set.not_mem_uIcc_of_lt /-
+/- warning: set.not_mem_uIcc_of_lt -> Set.not_mem_uIcc_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c b) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c b) -> (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b)))
+Case conversion may be inaccurate. Consider using '#align set.not_mem_uIcc_of_lt Set.not_mem_uIcc_of_ltₓ'. -/
 theorem not_mem_uIcc_of_lt (ha : c < a) (hb : c < b) : c ∉ [a, b] :=
   not_mem_Icc_of_lt <| lt_min_iff.mpr ⟨ha, hb⟩
 #align set.not_mem_uIcc_of_lt Set.not_mem_uIcc_of_lt
--/
 
-#print Set.not_mem_uIcc_of_gt /-
+/- warning: set.not_mem_uIcc_of_gt -> Set.not_mem_uIcc_of_gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b c) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) c (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b c) -> (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) c (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a b)))
+Case conversion may be inaccurate. Consider using '#align set.not_mem_uIcc_of_gt Set.not_mem_uIcc_of_gtₓ'. -/
 theorem not_mem_uIcc_of_gt (ha : a < c) (hb : b < c) : c ∉ [a, b] :=
   not_mem_Icc_of_gt <| max_lt_iff.mpr ⟨ha, hb⟩
 #align set.not_mem_uIcc_of_gt Set.not_mem_uIcc_of_gt
--/
 
 /- warning: set.uIcc_subset_uIcc_iff_le -> Set.uIcc_subset_uIcc_iff_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a₁ b₁) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a₂ b₂)) (And (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.min.{u1} α _inst_1 a₁ b₁)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.max.{u1} α _inst_1 a₁ b₁) (LinearOrder.max.{u1} α _inst_1 a₂ b₂)))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a₁ b₁) (Set.uIcc.{u1} α (LinearOrder.toLattice.{u1} α _inst_1) a₂ b₂)) (And (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.min.{u1} α _inst_1 a₁ b₁)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.max.{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 (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a₁ b₁) (Set.uIcc.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)) a₂ b₂)) (And (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₂) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a₁ b₁)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a₁ b₁) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a₂ b₂)))
 Case conversion may be inaccurate. Consider using '#align set.uIcc_subset_uIcc_iff_le Set.uIcc_subset_uIcc_iff_leₓ'. -/
@@ -379,17 +423,25 @@ def uIoc : α → α → Set α := fun a b => Ioc (min a b) (max a b)
 -- Below is a capital iota
 scoped[Interval] notation "Ι" => Set.uIoc
 
-#print Set.uIoc_of_le /-
+/- warning: set.uIoc_of_le -> Set.uIoc_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIoc.{u1} α _inst_1 a b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIoc.{u1} α _inst_1 a b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) a b))
+Case conversion may be inaccurate. Consider using '#align set.uIoc_of_le Set.uIoc_of_leₓ'. -/
 @[simp]
 theorem uIoc_of_le (h : a ≤ b) : Ι a b = Ioc a b := by simp [uIoc, h]
 #align set.uIoc_of_le Set.uIoc_of_le
--/
 
-#print Set.uIoc_of_lt /-
+/- warning: set.uIoc_of_lt -> Set.uIoc_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIoc.{u1} α _inst_1 a b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a) -> (Eq.{succ u1} (Set.{u1} α) (Set.uIoc.{u1} α _inst_1 a b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) b a))
+Case conversion may be inaccurate. Consider using '#align set.uIoc_of_lt Set.uIoc_of_ltₓ'. -/
 @[simp]
 theorem uIoc_of_lt (h : b < a) : Ι a b = Ioc b a := by simp [uIoc, h.le]
 #align set.uIoc_of_lt Set.uIoc_of_lt
--/
 
 /- warning: set.uIoc_eq_union -> Set.uIoc_eq_union is a dubious translation:
 lean 3 declaration is
@@ -400,31 +452,47 @@ Case conversion may be inaccurate. Consider using '#align set.uIoc_eq_union Set.
 theorem uIoc_eq_union : Ι a b = Ioc a b ∪ Ioc b a := by cases le_total a b <;> simp [uIoc, *]
 #align set.uIoc_eq_union Set.uIoc_eq_union
 
-#print Set.mem_uIoc /-
+/- warning: set.mem_uIoc -> Set.mem_uIoc is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c)) (Or (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a c)) (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c a) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c)) (Or (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c)) (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c a) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)))
+Case conversion may be inaccurate. Consider using '#align set.mem_uIoc Set.mem_uIocₓ'. -/
 theorem mem_uIoc : a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b := by
   simp only [uIoc_eq_union, mem_union, mem_Ioc]
 #align set.mem_uIoc Set.mem_uIoc
--/
 
-#print Set.not_mem_uIoc /-
+/- warning: set.not_mem_uIoc -> Set.not_mem_uIoc is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c))) (Or (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a c)) (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) c a) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, Iff (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c))) (Or (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c)) (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) c a) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a)))
+Case conversion may be inaccurate. Consider using '#align set.not_mem_uIoc Set.not_mem_uIocₓ'. -/
 theorem not_mem_uIoc : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a :=
   by
   simp only [uIoc_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]
   tauto
 #align set.not_mem_uIoc Set.not_mem_uIoc
--/
 
-#print Set.left_mem_uIoc /-
+/- warning: set.left_mem_uIoc -> Set.left_mem_uIoc is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.uIoc.{u1} α _inst_1 a b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIoc.{u1} α _inst_1 a b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b a)
+Case conversion may be inaccurate. Consider using '#align set.left_mem_uIoc Set.left_mem_uIocₓ'. -/
 @[simp]
 theorem left_mem_uIoc : a ∈ Ι a b ↔ b < a := by simp [mem_uIoc]
 #align set.left_mem_uIoc Set.left_mem_uIoc
--/
 
-#print Set.right_mem_uIoc /-
+/- warning: set.right_mem_uIoc -> Set.right_mem_uIoc is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Iff (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b (Set.uIoc.{u1} α _inst_1 a b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α}, Iff (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b (Set.uIoc.{u1} α _inst_1 a b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)
+Case conversion may be inaccurate. Consider using '#align set.right_mem_uIoc Set.right_mem_uIocₓ'. -/
 @[simp]
 theorem right_mem_uIoc : b ∈ Ι a b ↔ a < b := by simp [mem_uIoc]
 #align set.right_mem_uIoc Set.right_mem_uIoc
--/
 
 #print Set.forall_uIoc_iff /-
 theorem forall_uIoc_iff {P : α → Prop} :
@@ -467,13 +535,17 @@ theorem eq_of_mem_uIoc_of_mem_uIoc' : b ∈ Ι a c → c ∈ Ι a b → b = c :=
 #align set.eq_of_mem_uIoc_of_mem_uIoc' Set.eq_of_mem_uIoc_of_mem_uIoc'
 -/
 
-#print Set.eq_of_not_mem_uIoc_of_not_mem_uIoc /-
+/- warning: set.eq_of_not_mem_uIoc_of_not_mem_uIoc -> Set.eq_of_not_mem_uIoc_of_not_mem_uIoc is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b c) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c))) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b (Set.uIoc.{u1} α _inst_1 a c))) -> (Eq.{succ u1} α a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {c : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b c) -> (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.uIoc.{u1} α _inst_1 b c))) -> (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b (Set.uIoc.{u1} α _inst_1 a c))) -> (Eq.{succ u1} α a b)
+Case conversion may be inaccurate. Consider using '#align set.eq_of_not_mem_uIoc_of_not_mem_uIoc Set.eq_of_not_mem_uIoc_of_not_mem_uIocₓ'. -/
 theorem eq_of_not_mem_uIoc_of_not_mem_uIoc (ha : a ≤ c) (hb : b ≤ c) :
     a ∉ Ι b c → b ∉ Ι a c → a = b := by
   simp_rw [not_mem_uIoc] <;> rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩) <;> apply le_antisymm <;>
     first |assumption|exact le_of_lt ‹_›|cases not_le_of_lt ‹_› ‹_›
 #align set.eq_of_not_mem_uIoc_of_not_mem_uIoc Set.eq_of_not_mem_uIoc_of_not_mem_uIoc
--/
 
 #print Set.uIoc_injective_right /-
 theorem uIoc_injective_right (a : α) : Injective fun b => Ι b a :=

bump to nightly-2023-04-23-12

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

26e52e1f

Diff

@@ -202,12 +202,24 @@ theorem bdd_below_bdd_above_iff_subset_uIcc (s : Set α) :
 
 section Prod
 
+/- warning: set.uIcc_prod_uIcc -> Set.uIcc_prod_uIcc is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Lattice.{u1} α] [_inst_2 : Lattice.{u2} β] (a₁ : α) (a₂ : α) (b₁ : β) (b₂ : β), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β (Set.uIcc.{u1} α _inst_1 a₁ a₂) (Set.uIcc.{u2} β _inst_2 b₁ b₂)) (Set.uIcc.{max u1 u2} (Prod.{u1, u2} α β) (Prod.lattice.{u1, u2} α β _inst_1 _inst_2) (Prod.mk.{u1, u2} α β a₁ b₁) (Prod.mk.{u1, u2} α β a₂ b₂))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Lattice.{u2} α] [_inst_2 : Lattice.{u1} β] (a₁ : α) (a₂ : α) (b₁ : β) (b₂ : β), Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β (Set.uIcc.{u2} α _inst_1 a₁ a₂) (Set.uIcc.{u1} β _inst_2 b₁ b₂)) (Set.uIcc.{max u1 u2} (Prod.{u2, u1} α β) (Prod.lattice.{u2, u1} α β _inst_1 _inst_2) (Prod.mk.{u2, u1} α β a₁ b₁) (Prod.mk.{u2, u1} α β a₂ b₂))
+Case conversion may be inaccurate. Consider using '#align set.uIcc_prod_uIcc Set.uIcc_prod_uIccₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem uIcc_prod_uIcc (a₁ a₂ : α) (b₁ b₂ : β) : [a₁, a₂] ×ˢ [b₁, b₂] = [(a₁, b₁), (a₂, b₂)] :=
   Icc_prod_Icc _ _ _ _
 #align set.uIcc_prod_uIcc Set.uIcc_prod_uIcc
 
+/- warning: set.uIcc_prod_eq -> Set.uIcc_prod_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Lattice.{u1} α] [_inst_2 : Lattice.{u2} β] (a : Prod.{u1, u2} α β) (b : Prod.{u1, u2} α β), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.uIcc.{max u1 u2} (Prod.{u1, u2} α β) (Prod.lattice.{u1, u2} α β _inst_1 _inst_2) a b) (Set.prod.{u1, u2} α β (Set.uIcc.{u1} α _inst_1 (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (Set.uIcc.{u2} β _inst_2 (Prod.snd.{u1, u2} α β a) (Prod.snd.{u1, u2} α β b)))
+but is expected to have type
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Lattice.{u2} α] [_inst_2 : Lattice.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (Prod.{u2, u1} α β)) (Set.uIcc.{max u2 u1} (Prod.{u2, u1} α β) (Prod.lattice.{u2, u1} α β _inst_1 _inst_2) a b) (Set.prod.{u2, u1} α β (Set.uIcc.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (Set.uIcc.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b)))
+Case conversion may be inaccurate. Consider using '#align set.uIcc_prod_eq Set.uIcc_prod_eqₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem uIcc_prod_eq (a b : α × β) : [a, b] = [a.1, b.1] ×ˢ [a.2, b.2] := by simp
 #align set.uIcc_prod_eq Set.uIcc_prod_eq

bump to nightly-2023-04-21-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/246f6f7989ff86bd07e1b014846f11304f33cf9e

38c06b34

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou
 
 ! This file was ported from Lean 3 source module data.set.intervals.unordered_interval
-! leanprover-community/mathlib commit 9003f28797c0664a49e4179487267c494477d853
+! leanprover-community/mathlib commit 4020ddee5b4580a409bfda7d2f42726ce86ae674
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -51,7 +51,7 @@ namespace Set
 
 section Lattice
 
-variable [Lattice α] {a a₁ a₂ b b₁ b₂ c x : α}
+variable [Lattice α] [Lattice β] {a a₁ a₂ b b₁ b₂ c x : α}
 
 #print Set.uIcc /-
 /-- `uIcc a b` is the set of elements lying between `a` and `b`, with `a` and `b` included.
@@ -200,6 +200,20 @@ theorem bdd_below_bdd_above_iff_subset_uIcc (s : Set α) :
 #align set.bdd_below_bdd_above_iff_subset_uIcc Set.bdd_below_bdd_above_iff_subset_uIcc
 -/
 
+section Prod
+
+/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+@[simp]
+theorem uIcc_prod_uIcc (a₁ a₂ : α) (b₁ b₂ : β) : [a₁, a₂] ×ˢ [b₁, b₂] = [(a₁, b₁), (a₂, b₂)] :=
+  Icc_prod_Icc _ _ _ _
+#align set.uIcc_prod_uIcc Set.uIcc_prod_uIcc
+
+/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+theorem uIcc_prod_eq (a b : α × β) : [a, b] = [a.1, b.1] ×ˢ [a.2, b.2] := by simp
+#align set.uIcc_prod_eq Set.uIcc_prod_eq
+
+end Prod
+
 end Lattice
 
 open Interval

bump to nightly-2023-03-01-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

20cadee0

Diff

@@ -335,7 +335,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LinearOrder.{u2} α] [_inst_2 : LinearOrder.{u1} β] {f : α -> β} {s : Set.{u2} α}, Iff (Or (MonotoneOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) f s) (AntitoneOn.{u2, u1} α β (PartialOrder.toPreorder.{u2} α (SemilatticeInf.toPartialOrder.{u2} α (Lattice.toSemilatticeInf.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1))))) (PartialOrder.toPreorder.{u1} β (SemilatticeInf.toPartialOrder.{u1} β (Lattice.toSemilatticeInf.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2))))) f s)) (forall (a : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s) -> (forall (b : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) b s) -> (forall (c : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) c s) -> (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) c (Set.uIcc.{u2} α (DistribLattice.toLattice.{u2} α (instDistribLattice.{u2} α _inst_1)) a b)) -> (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (f c) (Set.uIcc.{u1} β (DistribLattice.toLattice.{u1} β (instDistribLattice.{u1} β _inst_2)) (f a) (f b))))))
 Case conversion may be inaccurate. Consider using '#align set.monotone_on_or_antitone_on_iff_uIcc Set.monotoneOn_or_antitoneOn_iff_uIccₓ'. -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b c «expr ∈ » s) -/
 theorem monotoneOn_or_antitoneOn_iff_uIcc :
     MonotoneOn f s ∨ AntitoneOn f s ↔
       ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s) (c) (_ : c ∈ s), c ∈ [a, b] → f c ∈ [f a, f b] :=

bump to nightly-2023-02-28-04

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

2097f8af

Diff

@@ -170,11 +170,15 @@ theorem uIcc_subset_uIcc_iff_mem : [a₁, b₁] ⊆ [a₂, b₂] ↔ a₁ ∈ [a
 #align set.uIcc_subset_uIcc_iff_mem Set.uIcc_subset_uIcc_iff_mem
 -/
 
-#print Set.uIcc_subset_uIcc_iff_le' /-
+/- warning: set.uIcc_subset_uIcc_iff_le' -> Set.uIcc_subset_uIcc_iff_le' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.uIcc.{u1} α _inst_1 a₁ b₁) (Set.uIcc.{u1} α _inst_1 a₂ b₂)) (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)) a₂ b₂) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)) a₁ b₁)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₁ b₁) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₂ b₂)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Lattice.{u1} α] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, Iff (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.uIcc.{u1} α _inst_1 a₁ b₁) (Set.uIcc.{u1} α _inst_1 a₂ b₂)) (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Inf.inf.{u1} α (Lattice.toInf.{u1} α _inst_1) a₂ b₂) (Inf.inf.{u1} α (Lattice.toInf.{u1} α _inst_1) a₁ b₁)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_1)))) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₁ b₁) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_1)) a₂ b₂)))
+Case conversion may be inaccurate. Consider using '#align set.uIcc_subset_uIcc_iff_le' Set.uIcc_subset_uIcc_iff_le'ₓ'. -/
 theorem uIcc_subset_uIcc_iff_le' : [a₁, b₁] ⊆ [a₂, b₂] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂ :=
   Icc_subset_Icc_iff inf_le_sup
 #align set.uIcc_subset_uIcc_iff_le' Set.uIcc_subset_uIcc_iff_le'
--/
 
 #print Set.uIcc_subset_uIcc_right /-
 theorem uIcc_subset_uIcc_right (h : x ∈ [a, b]) : [x, b] ⊆ [a, b] :=

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: Move intervals (#11765)

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

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

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

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

c7fa7063

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2020 Zhouhang Zhou. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou
 -/
-import Mathlib.Data.Set.Intervals.Image
+import Mathlib.Order.Interval.Set.Image
 import Mathlib.Order.Bounds.Basic
 import Mathlib.Tactic.Common

chore: classify simp can do this porting notes (#10619)

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

de765f60

Diff

@@ -83,7 +83,7 @@ lemma uIcc_of_lt (h : a < b) : [[a, b]] = Icc a b := uIcc_of_le h.le
 lemma uIcc_of_gt (h : b < a) : [[a, b]] = Icc b a := uIcc_of_ge h.le
 #align set.uIcc_of_gt Set.uIcc_of_gt
 
--- Porting note: `simp` can prove this
+-- Porting note (#10618): `simp` can prove this
 -- @[simp]
 lemma uIcc_self : [[a, a]] = {a} := by simp [uIcc]
 #align set.uIcc_self Set.uIcc_self

feat(Topology/Order): assorted lemmas (#10556)

Add upperBounds_closure, lowerBounds_closure, bddAbove_closure, bddBelow_closure.
Add IsAntichain.interior_eq_empty.
Generalize nhds_left'_le_nhds_ne and nhds_right'_le_nhds_ne to a Preorder.

Partly forward-ports https://github.com/leanprover-community/mathlib/pull/16976

8f525447

Diff

@@ -7,7 +7,7 @@ import Mathlib.Data.Set.Intervals.Image
 import Mathlib.Order.Bounds.Basic
 import Mathlib.Tactic.Common
 
-#align_import data.set.intervals.unordered_interval from "leanprover-community/mathlib"@"4020ddee5b4580a409bfda7d2f42726ce86ae674"
+#align_import data.set.intervals.unordered_interval from "leanprover-community/mathlib"@"3ba15165bd6927679be7c22d6091a87337e3cd0c"
 
 /-!
 # Intervals without endpoints ordering

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

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

Zulip thread

Important changes

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

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

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

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

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

Similarly, MyEquivClass should take EquivLike as a parameter.

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

Remaining issues

Slower (failing) search

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

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

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

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

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

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

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

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

`simp` not firing sometimes

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

Missing instances due to unification failing

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

Workaround for issues

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

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

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

c6a73d4f

Diff

@@ -62,7 +62,9 @@ scoped[Interval] notation "[[" a ", " b "]]" => Set.uIcc a b
 
 open Interval
 
-@[simp] lemma dual_uIcc (a b : α) : [[toDual a, toDual b]] = ofDual ⁻¹' [[a, b]] := dual_Icc
+@[simp] lemma dual_uIcc (a b : α) : [[toDual a, toDual b]] = ofDual ⁻¹' [[a, b]] :=
+  -- Note: needed to hint `(α := α)` after #8386 (elaboration order?)
+  dual_Icc (α := α)
 #align set.dual_uIcc Set.dual_uIcc
 
 @[simp]

chore(*): replace $ with <| (#9319)

See Zulip thread for the discussion.

9f6d3388

Diff

@@ -221,9 +221,9 @@ theorem Icc_min_max : Icc (min a b) (max a b) = [[a, b]] :=
   rfl
 #align set.Icc_min_max Set.Icc_min_max
 
-lemma uIcc_of_not_le (h : ¬a ≤ b) : [[a, b]] = Icc b a := uIcc_of_gt $ lt_of_not_ge h
+lemma uIcc_of_not_le (h : ¬a ≤ b) : [[a, b]] = Icc b a := uIcc_of_gt <| lt_of_not_ge h
 #align set.uIcc_of_not_le Set.uIcc_of_not_le
-lemma uIcc_of_not_ge (h : ¬b ≤ a) : [[a, b]] = Icc a b := uIcc_of_lt $ lt_of_not_ge h
+lemma uIcc_of_not_ge (h : ¬b ≤ a) : [[a, b]] = Icc a b := uIcc_of_lt <| lt_of_not_ge h
 #align set.uIcc_of_not_ge Set.uIcc_of_not_ge
 
 lemma uIcc_eq_union : [[a, b]] = Icc a b ∪ Icc b a := by rw [Icc_union_Icc', max_comm] <;> rfl

chore(*): use ∃ x ∈ s, _ instead of ∃ (x) (_ : x ∈ s), _ (#9184)

Search for [∀∃].*(_ and manually replace some occurrences with more readable versions. In case of ∀, the new expressions are defeq to the old ones. In case of ∃, they differ by exists_prop.

In some rare cases, golf proofs that needed fixing.

14c72960

Diff

@@ -266,7 +266,7 @@ lemma monotone_or_antitone_iff_uIcc :
 -- Porting note: mathport expands the syntactic sugar `∀ a b c ∈ s` differently than Lean3
 lemma monotoneOn_or_antitoneOn_iff_uIcc :
     MonotoneOn f s ∨ AntitoneOn f s ↔
-      ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s) (c) (_ : c ∈ s), c ∈ [[a, b]] → f c ∈ [[f a, f b]] :=
+      ∀ᵉ (a ∈ s) (b ∈ s) (c ∈ s), c ∈ [[a, b]] → f c ∈ [[f a, f b]] :=
   by simp [monotoneOn_iff_monotone, antitoneOn_iff_antitone, monotone_or_antitone_iff_uIcc,
     mem_uIcc]
 #align set.monotone_on_or_antitone_on_iff_uIcc Set.monotoneOn_or_antitoneOn_iff_uIcc

chore: remove uses of cases' (#9171)

I literally went through and regex'd some uses of cases', replacing them with rcases; this is meant to be a low effort PR as I hope that tools can do this in the future.

rcases is an easier replacement than cases, though with better tools we could in future do a second pass converting simple rcases added here (and existing ones) to cases.

3fca282c

Diff

@@ -248,9 +248,7 @@ lemma uIcc_subset_uIcc_iff_le :
 /-- A sort of triangle inequality. -/
 lemma uIcc_subset_uIcc_union_uIcc : [[a, c]] ⊆ [[a, b]] ∪ [[b, c]] := fun x => by
   simp only [mem_uIcc, mem_union]
-  cases' le_total a c with h1 h1 <;>
-  cases' le_total x b with h2 h2 <;>
-  tauto
+  rcases le_total x b with h2 | h2 <;> tauto
 #align set.uIcc_subset_uIcc_union_uIcc Set.uIcc_subset_uIcc_union_uIcc
 
 lemma monotone_or_antitone_iff_uIcc :

chore: space after ← (#8178)

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

5fb9beab

Diff

@@ -187,12 +187,12 @@ variable [Lattice β] {f : α → β} {s : Set α} {a b : α}
 
 lemma _root_.MonotoneOn.mapsTo_uIcc (hf : MonotoneOn f (uIcc a b)) :
     MapsTo f (uIcc a b) (uIcc (f a) (f b)) := by
-  rw [uIcc, uIcc, ←hf.map_sup, ←hf.map_inf] <;>
+  rw [uIcc, uIcc, ← hf.map_sup, ← hf.map_inf] <;>
     apply_rules [left_mem_uIcc, right_mem_uIcc, hf.mapsTo_Icc]
 
 lemma _root_.AntitoneOn.mapsTo_uIcc (hf : AntitoneOn f (uIcc a b)) :
     MapsTo f (uIcc a b) (uIcc (f a) (f b)) := by
-  rw [uIcc, uIcc, ←hf.map_sup, ←hf.map_inf] <;>
+  rw [uIcc, uIcc, ← hf.map_sup, ← hf.map_inf] <;>
     apply_rules [left_mem_uIcc, right_mem_uIcc, hf.mapsTo_Icc]
 
 lemma _root_.Monotone.mapsTo_uIcc (hf : Monotone f) : MapsTo f (uIcc a b) (uIcc (f a) (f b)) :=

feat(Data/Set/Intervals/Image): Complete API (#7146)

Dualise all existing lemmas and prove their strictly monotone versions.

The lemmas are grouped as

mapsTo, image_subset
- On, not On
  - Monotone, Antitone, StrictMono, StrictAnti
    - Ixi, Iix, Ixx

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

dae39b2a

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2020 Zhouhang Zhou. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou
 -/
+import Mathlib.Data.Set.Intervals.Image
 import Mathlib.Order.Bounds.Basic
-import Mathlib.Data.Set.Intervals.Basic
 import Mathlib.Tactic.Common
 
 #align_import data.set.intervals.unordered_interval from "leanprover-community/mathlib"@"4020ddee5b4580a409bfda7d2f42726ce86ae674"
@@ -180,8 +180,42 @@ lemma uIcc_injective_left (a : α) : Injective (uIcc a) := by
 end DistribLattice
 
 section LinearOrder
+variable [LinearOrder α]
 
-variable [LinearOrder α] [LinearOrder β] {f : α → β} {s : Set α} {a a₁ a₂ b b₁ b₂ c x : α}
+section Lattice
+variable [Lattice β] {f : α → β} {s : Set α} {a b : α}
+
+lemma _root_.MonotoneOn.mapsTo_uIcc (hf : MonotoneOn f (uIcc a b)) :
+    MapsTo f (uIcc a b) (uIcc (f a) (f b)) := by
+  rw [uIcc, uIcc, ←hf.map_sup, ←hf.map_inf] <;>
+    apply_rules [left_mem_uIcc, right_mem_uIcc, hf.mapsTo_Icc]
+
+lemma _root_.AntitoneOn.mapsTo_uIcc (hf : AntitoneOn f (uIcc a b)) :
+    MapsTo f (uIcc a b) (uIcc (f a) (f b)) := by
+  rw [uIcc, uIcc, ←hf.map_sup, ←hf.map_inf] <;>
+    apply_rules [left_mem_uIcc, right_mem_uIcc, hf.mapsTo_Icc]
+
+lemma _root_.Monotone.mapsTo_uIcc (hf : Monotone f) : MapsTo f (uIcc a b) (uIcc (f a) (f b)) :=
+  (hf.monotoneOn _).mapsTo_uIcc
+
+lemma _root_.Antitone.mapsTo_uIcc (hf : Antitone f) : MapsTo f (uIcc a b) (uIcc (f a) (f b)) :=
+  (hf.antitoneOn _).mapsTo_uIcc
+
+lemma _root_.MonotoneOn.image_uIcc_subset (hf : MonotoneOn f (uIcc a b)) :
+    f '' uIcc a b ⊆ uIcc (f a) (f b) := hf.mapsTo_uIcc.image_subset
+
+lemma _root_.AntitoneOn.image_uIcc_subset (hf : AntitoneOn f (uIcc a b)) :
+    f '' uIcc a b ⊆ uIcc (f a) (f b) := hf.mapsTo_uIcc.image_subset
+
+lemma _root_.Monotone.image_uIcc_subset (hf : Monotone f) : f '' uIcc a b ⊆ uIcc (f a) (f b) :=
+  (hf.monotoneOn _).image_uIcc_subset
+
+lemma _root_.Antitone.image_uIcc_subset (hf : Antitone f) : f '' uIcc a b ⊆ uIcc (f a) (f b) :=
+  (hf.antitoneOn _).image_uIcc_subset
+
+end Lattice
+
+variable [LinearOrder β] {f : α → β} {s : Set α} {a a₁ a₂ b b₁ b₂ c d x : α}
 
 theorem Icc_min_max : Icc (min a b) (max a b) = [[a, b]] :=
   rfl

chore: only four spaces for subsequent lines (#7286)

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

0c7d6fa5

Diff

@@ -105,17 +105,17 @@ lemma mem_uIcc_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [[a, b]] := Icc_subse
 #align set.mem_uIcc_of_ge Set.mem_uIcc_of_ge
 
 lemma uIcc_subset_uIcc (h₁ : a₁ ∈ [[a₂, b₂]]) (h₂ : b₁ ∈ [[a₂, b₂]]) :
-  [[a₁, b₁]] ⊆ [[a₂, b₂]] :=
+    [[a₁, b₁]] ⊆ [[a₂, b₂]] :=
   Icc_subset_Icc (le_inf h₁.1 h₂.1) (sup_le h₁.2 h₂.2)
 #align set.uIcc_subset_uIcc Set.uIcc_subset_uIcc
 
 lemma uIcc_subset_Icc (ha : a₁ ∈ Icc a₂ b₂) (hb : b₁ ∈ Icc a₂ b₂) :
-  [[a₁, b₁]] ⊆ Icc a₂ b₂ :=
+    [[a₁, b₁]] ⊆ Icc a₂ b₂ :=
   Icc_subset_Icc (le_inf ha.1 hb.1) (sup_le ha.2 hb.2)
 #align set.uIcc_subset_Icc Set.uIcc_subset_Icc
 
 lemma uIcc_subset_uIcc_iff_mem :
-  [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₁ ∈ [[a₂, b₂]] ∧ b₁ ∈ [[a₂, b₂]] :=
+    [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₁ ∈ [[a₂, b₂]] ∧ b₁ ∈ [[a₂, b₂]] :=
   Iff.intro (fun h => ⟨h left_mem_uIcc, h right_mem_uIcc⟩) fun h =>
     uIcc_subset_uIcc h.1 h.2
 #align set.uIcc_subset_uIcc_iff_mem Set.uIcc_subset_uIcc_iff_mem

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

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

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

(Oh

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

4f3418a7

Diff

@@ -5,6 +5,7 @@ Authors: Zhouhang Zhou
 -/
 import Mathlib.Order.Bounds.Basic
 import Mathlib.Data.Set.Intervals.Basic
+import Mathlib.Tactic.Common
 
 #align_import data.set.intervals.unordered_interval from "leanprover-community/mathlib"@"4020ddee5b4580a409bfda7d2f42726ce86ae674"

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

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

This has nice performance benefits.

32de3f67

Diff

@@ -39,7 +39,7 @@ open Function
 
 open OrderDual (toDual ofDual)
 
-variable {α β : Type _}
+variable {α β : Type*}
 
 namespace Set

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Zhouhang Zhou. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou
-
-! This file was ported from Lean 3 source module data.set.intervals.unordered_interval
-! leanprover-community/mathlib commit 4020ddee5b4580a409bfda7d2f42726ce86ae674
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Bounds.Basic
 import Mathlib.Data.Set.Intervals.Basic
 
+#align_import data.set.intervals.unordered_interval from "leanprover-community/mathlib"@"4020ddee5b4580a409bfda7d2f42726ce86ae674"
+
 /-!
 # Intervals without endpoints ordering

chore: add space after exacts (#4945)

Too often tempted to change these during other PRs, so doing a mass edit here.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

bf799bb9

Diff

@@ -225,7 +225,7 @@ lemma monotone_or_antitone_iff_uIcc :
     Monotone f ∨ Antitone f ↔ ∀ a b c, c ∈ [[a, b]] → f c ∈ [[f a, f b]] := by
   constructor
   · rintro (hf | hf) a b c <;> simp_rw [← Icc_min_max, ← hf.map_min, ← hf.map_max]
-    exacts[fun hc => ⟨hf hc.1, hf hc.2⟩, fun hc => ⟨hf hc.2, hf hc.1⟩]
+    exacts [fun hc => ⟨hf hc.1, hf hc.2⟩, fun hc => ⟨hf hc.2, hf hc.1⟩]
   contrapose!
   rw [not_monotone_not_antitone_iff_exists_le_le]
   rintro ⟨a, b, c, hab, hbc, ⟨hfab, hfcb⟩ | ⟨hfba, hfbc⟩⟩

chore: fix upper/lowercase in comments (#4360)

Run a non-interactive version of fix-comments.py on all files.
Go through the diff and manually add/discard/edit chunks.

27d257fc

Diff

@@ -32,7 +32,7 @@ subcube containing both `a` and `b`.
 
 ## Notation
 
-We use the localized notation `[[a, b]]` for `uIcc a b`. One can open the locale `interval` to
+We use the localized notation `[[a, b]]` for `uIcc a b`. One can open the locale `Interval` to
 make the notation available.
 
 -/

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

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

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

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

a4eaf1c4

Diff

@@ -10,8 +10,6 @@ Authors: Zhouhang Zhou
 -/
 import Mathlib.Order.Bounds.Basic
 import Mathlib.Data.Set.Intervals.Basic
-import Mathlib.Tactic.ScopedNS
-import Mathlib.Tactic.Tauto
 
 /-!
 # Intervals without endpoints ordering

chore: forward-port leanprover-community/mathlib#18835 (#3573)

75e569b6

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou
 
 ! This file was ported from Lean 3 source module data.set.intervals.unordered_interval
-! leanprover-community/mathlib commit 9003f28797c0664a49e4179487267c494477d853
+! leanprover-community/mathlib commit 4020ddee5b4580a409bfda7d2f42726ce86ae674
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -50,7 +50,7 @@ namespace Set
 
 section Lattice
 
-variable [Lattice α] {a a₁ a₂ b b₁ b₂ c x : α}
+variable [Lattice α] [Lattice β] {a a₁ a₂ b b₁ b₂ c x : α}
 
 /-- `uIcc a b` is the set of elements lying between `a` and `b`, with `a` and `b` included.
 Note that we define it more generally in a lattice as `Set.Icc (a ⊓ b) (a ⊔ b)`. In a product type,
@@ -143,6 +143,19 @@ lemma bdd_below_bdd_above_iff_subset_uIcc (s : Set α) :
     ⟨fun ⟨a, b, h⟩ => ⟨a, b, fun _ hx => Icc_subset_uIcc (h hx)⟩, fun ⟨_, _, h⟩ => ⟨_, _, h⟩⟩
 #align set.bdd_below_bdd_above_iff_subset_uIcc Set.bdd_below_bdd_above_iff_subset_uIcc
 
+section Prod
+
+@[simp]
+theorem uIcc_prod_uIcc (a₁ a₂ : α) (b₁ b₂ : β) :
+    [[a₁, a₂]] ×ˢ [[b₁, b₂]] = [[(a₁, b₁), (a₂, b₂)]] :=
+  Icc_prod_Icc _ _ _ _
+#align set.uIcc_prod_uIcc Set.uIcc_prod_uIcc
+
+theorem uIcc_prod_eq (a b : α × β) : [[a, b]] = [[a.1, b.1]] ×ˢ [[a.2, b.2]] := by simp
+#align set.uIcc_prod_eq Set.uIcc_prod_eq
+
+end Prod
+
 end Lattice
 
 open Interval

feat: port Data.Finset.LocallyFinite (#1837)

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Jon Eugster <eugster.jon@gmail.com> Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com>

e2c39a45

Diff

@@ -60,8 +60,11 @@ def uIcc (a b : α) : Set α := Icc (a ⊓ b) (a ⊔ b)
 
 -- Porting note: temporarily remove `scoped[uIcc]` and use `[[]]` instead of `[]` before a
 -- workaround is found.
+-- Porting note 2 : now `scoped[Interval]` works again.
 /-- `[[a, b]]` denotes the set of elements lying between `a` and `b`, inclusive. -/
-notation "[[" a ", " b "]]" => Set.uIcc a b
+scoped[Interval] notation "[[" a ", " b "]]" => Set.uIcc a b
+
+open Interval
 
 @[simp] lemma dual_uIcc (a b : α) : [[toDual a, toDual b]] = ofDual ⁻¹' [[a, b]] := dual_Icc
 #align set.dual_uIcc Set.dual_uIcc
@@ -142,8 +145,7 @@ lemma bdd_below_bdd_above_iff_subset_uIcc (s : Set α) :
 
 end Lattice
 
--- Porting note: fix scoped notation
--- open Interval
+open Interval
 
 section DistribLattice

Match https://github.com/leanprover-community/mathlib/pull/18104

chore: Rename intervals to uIcc/uIoc (#1496)

bd0eb8a4

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Zhouhang Zhou
 
 ! This file was ported from Lean 3 source module data.set.intervals.unordered_interval
-! leanprover-community/mathlib commit a59dad53320b73ef180174aae867addd707ef00e
+! leanprover-community/mathlib commit 9003f28797c0664a49e4179487267c494477d853
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,25 +16,25 @@ import Mathlib.Tactic.Tauto
 /-!
 # Intervals without endpoints ordering
 
-In any lattice `α`, we define `interval a b` to be `Icc (a ⊓ b) (a ⊔ b)`, which in a linear order is
+In any lattice `α`, we define `uIcc a b` to be `Icc (a ⊓ b) (a ⊔ b)`, which in a linear order is
 the set of elements lying between `a` and `b`.
 
 `Icc a b` requires the assumption `a ≤ b` to be meaningful, which is sometimes inconvenient. The
 interval as defined in this file is always the set of things lying between `a` and `b`, regardless
 of the relative order of `a` and `b`.
 
-For real numbers, `interval a b` is the same as `segment ℝ a b`.
+For real numbers, `uIcc a b` is the same as `segment ℝ a b`.
 
-In a product or pi type, `interval a b` is the smallest box containing `a` and `b`. For example,
-`interval (1, -1) (-1, 1) = Icc (-1, -1) (1, 1)` is the square of vertices `(1, -1)`, `(-1, -1)`,
+In a product or pi type, `uIcc a b` is the smallest box containing `a` and `b`. For example,
+`uIcc (1, -1) (-1, 1) = Icc (-1, -1) (1, 1)` is the square of vertices `(1, -1)`, `(-1, -1)`,
 `(-1, 1)`, `(1, 1)`.
 
-In `Finset α` (seen as a hypercube of dimension `Fintype.card α`), `interval a b` is the smallest
+In `Finset α` (seen as a hypercube of dimension `Fintype.card α`), `uIcc a b` is the smallest
 subcube containing both `a` and `b`.
 
 ## Notation
 
-We use the localized notation `[[a, b]]` for `interval a b`. One can open the locale `interval` to
+We use the localized notation `[[a, b]]` for `uIcc a b`. One can open the locale `interval` to
 make the notation available.
 
 -/
@@ -52,114 +52,93 @@ section Lattice
 
 variable [Lattice α] {a a₁ a₂ b b₁ b₂ c x : α}
 
-/-- `interval a b` is the set of elements lying between `a` and `b`, with `a` and `b` included.
+/-- `uIcc a b` is the set of elements lying between `a` and `b`, with `a` and `b` included.
 Note that we define it more generally in a lattice as `Set.Icc (a ⊓ b) (a ⊔ b)`. In a product type,
-`interval` corresponds to the bounding box of the two elements. -/
-def interval (a b : α) : Set α :=
-  Icc (a ⊓ b) (a ⊔ b)
-#align set.interval Set.interval
+`uIcc` corresponds to the bounding box of the two elements. -/
+def uIcc (a b : α) : Set α := Icc (a ⊓ b) (a ⊔ b)
+#align set.uIcc Set.uIcc
 
--- Porting note: temporarily remove `scoped[Interval]` and use `[[]]` instead of `[]` before a
+-- Porting note: temporarily remove `scoped[uIcc]` and use `[[]]` instead of `[]` before a
 -- workaround is found.
 /-- `[[a, b]]` denotes the set of elements lying between `a` and `b`, inclusive. -/
-notation "[[" a ", " b "]]" => Set.interval a b
+notation "[[" a ", " b "]]" => Set.uIcc a b
 
-@[simp]
-theorem dual_interval (a b : α) : [[toDual a, toDual b]] = ofDual ⁻¹' [[a, b]] :=
-  dual_Icc
-#align set.dual_interval Set.dual_interval
+@[simp] lemma dual_uIcc (a b : α) : [[toDual a, toDual b]] = ofDual ⁻¹' [[a, b]] := dual_Icc
+#align set.dual_uIcc Set.dual_uIcc
 
 @[simp]
-theorem interval_of_le (h : a ≤ b) : [[a, b]] = Icc a b := by
-  rw [interval, inf_eq_left.2 h, sup_eq_right.2 h]
-#align set.interval_of_le Set.interval_of_le
+lemma uIcc_of_le (h : a ≤ b) : [[a, b]] = Icc a b := by rw [uIcc, inf_eq_left.2 h, sup_eq_right.2 h]
+#align set.uIcc_of_le Set.uIcc_of_le
 
 @[simp]
-theorem interval_of_ge (h : b ≤ a) : [[a, b]] = Icc b a := by
-  rw [interval, inf_eq_right.2 h, sup_eq_left.2 h]
-#align set.interval_of_ge Set.interval_of_ge
-
-theorem interval_swap (a b : α) : [[a, b]] = [[b, a]] := by simp_rw [interval, inf_comm, sup_comm]
-#align set.interval_swap Set.interval_swap
+lemma uIcc_of_ge (h : b ≤ a) : [[a, b]] = Icc b a := by rw [uIcc, inf_eq_right.2 h, sup_eq_left.2 h]
+#align set.uIcc_of_ge Set.uIcc_of_ge
 
-theorem interval_of_lt (h : a < b) : [[a, b]] = Icc a b :=
-  interval_of_le (le_of_lt h)
-#align set.interval_of_lt Set.interval_of_lt
+lemma uIcc_comm (a b : α) : [[a, b]] = [[b, a]] := by simp_rw [uIcc, inf_comm, sup_comm]
+#align set.uIcc_comm Set.uIcc_comm
 
-theorem interval_of_gt (h : b < a) : [[a, b]] = Icc b a :=
-  interval_of_ge (le_of_lt h)
-#align set.interval_of_gt Set.interval_of_gt
+lemma uIcc_of_lt (h : a < b) : [[a, b]] = Icc a b := uIcc_of_le h.le
+#align set.uIcc_of_lt Set.uIcc_of_lt
+lemma uIcc_of_gt (h : b < a) : [[a, b]] = Icc b a := uIcc_of_ge h.le
+#align set.uIcc_of_gt Set.uIcc_of_gt
 
 -- Porting note: `simp` can prove this
 -- @[simp]
-theorem interval_self : [[a, a]] = {a} := by simp [interval]
-#align set.interval_self Set.interval_self
-
-@[simp]
-theorem nonempty_interval : [[a, b]].Nonempty :=
-  nonempty_Icc.2 inf_le_sup
-#align set.nonempty_interval Set.nonempty_interval
+lemma uIcc_self : [[a, a]] = {a} := by simp [uIcc]
+#align set.uIcc_self Set.uIcc_self
 
-theorem Icc_subset_interval : Icc a b ⊆ [[a, b]] :=
-  Icc_subset_Icc inf_le_left le_sup_right
-#align set.Icc_subset_interval Set.Icc_subset_interval
+@[simp] lemma nonempty_uIcc : [[a, b]].Nonempty := nonempty_Icc.2 inf_le_sup
+#align set.nonempty_uIcc Set.nonempty_uIcc
 
-theorem Icc_subset_interval' : Icc b a ⊆ [[a, b]] :=
-  Icc_subset_Icc inf_le_right le_sup_left
-#align set.Icc_subset_interval' Set.Icc_subset_interval'
-
-@[simp]
-theorem left_mem_interval : a ∈ [[a, b]] :=
-  ⟨inf_le_left, le_sup_left⟩
-#align set.left_mem_interval Set.left_mem_interval
-
-@[simp]
-theorem right_mem_interval : b ∈ [[a, b]] :=
-  ⟨inf_le_right, le_sup_right⟩
-#align set.right_mem_interval Set.right_mem_interval
+lemma Icc_subset_uIcc : Icc a b ⊆ [[a, b]] := Icc_subset_Icc inf_le_left le_sup_right
+#align set.Icc_subset_uIcc Set.Icc_subset_uIcc
+lemma Icc_subset_uIcc' : Icc b a ⊆ [[a, b]] := Icc_subset_Icc inf_le_right le_sup_left
+#align set.Icc_subset_uIcc' Set.Icc_subset_uIcc'
 
-theorem mem_interval_of_le (ha : a ≤ x) (hb : x ≤ b) : x ∈ [[a, b]] :=
-  Icc_subset_interval ⟨ha, hb⟩
-#align set.mem_interval_of_le Set.mem_interval_of_le
+@[simp] lemma left_mem_uIcc : a ∈ [[a, b]] := ⟨inf_le_left, le_sup_left⟩
+#align set.left_mem_uIcc Set.left_mem_uIcc
+@[simp] lemma right_mem_uIcc : b ∈ [[a, b]] := ⟨inf_le_right, le_sup_right⟩
+#align set.right_mem_uIcc Set.right_mem_uIcc
 
-theorem mem_interval_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [[a, b]] :=
-  Icc_subset_interval' ⟨hb, ha⟩
-#align set.mem_interval_of_ge Set.mem_interval_of_ge
+lemma mem_uIcc_of_le (ha : a ≤ x) (hb : x ≤ b) : x ∈ [[a, b]] := Icc_subset_uIcc ⟨ha, hb⟩
+#align set.mem_uIcc_of_le Set.mem_uIcc_of_le
+lemma mem_uIcc_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [[a, b]] := Icc_subset_uIcc' ⟨hb, ha⟩
+#align set.mem_uIcc_of_ge Set.mem_uIcc_of_ge
 
-theorem interval_subset_interval (h₁ : a₁ ∈ [[a₂, b₂]]) (h₂ : b₁ ∈ [[a₂, b₂]]) :
+lemma uIcc_subset_uIcc (h₁ : a₁ ∈ [[a₂, b₂]]) (h₂ : b₁ ∈ [[a₂, b₂]]) :
   [[a₁, b₁]] ⊆ [[a₂, b₂]] :=
   Icc_subset_Icc (le_inf h₁.1 h₂.1) (sup_le h₁.2 h₂.2)
-#align set.interval_subset_interval Set.interval_subset_interval
+#align set.uIcc_subset_uIcc Set.uIcc_subset_uIcc
 
-theorem interval_subset_Icc (ha : a₁ ∈ Icc a₂ b₂) (hb : b₁ ∈ Icc a₂ b₂) :
+lemma uIcc_subset_Icc (ha : a₁ ∈ Icc a₂ b₂) (hb : b₁ ∈ Icc a₂ b₂) :
   [[a₁, b₁]] ⊆ Icc a₂ b₂ :=
   Icc_subset_Icc (le_inf ha.1 hb.1) (sup_le ha.2 hb.2)
-#align set.interval_subset_Icc Set.interval_subset_Icc
+#align set.uIcc_subset_Icc Set.uIcc_subset_Icc
 
-theorem interval_subset_interval_iff_mem :
+lemma uIcc_subset_uIcc_iff_mem :
   [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₁ ∈ [[a₂, b₂]] ∧ b₁ ∈ [[a₂, b₂]] :=
-  Iff.intro (fun h => ⟨h left_mem_interval, h right_mem_interval⟩) fun h =>
-    interval_subset_interval h.1 h.2
-#align set.interval_subset_interval_iff_mem Set.interval_subset_interval_iff_mem
+  Iff.intro (fun h => ⟨h left_mem_uIcc, h right_mem_uIcc⟩) fun h =>
+    uIcc_subset_uIcc h.1 h.2
+#align set.uIcc_subset_uIcc_iff_mem Set.uIcc_subset_uIcc_iff_mem
 
-theorem interval_subset_interval_iff_le' :
+lemma uIcc_subset_uIcc_iff_le' :
     [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂ :=
   Icc_subset_Icc_iff inf_le_sup
-#align set.interval_subset_interval_iff_le' Set.interval_subset_interval_iff_le'
+#align set.uIcc_subset_uIcc_iff_le' Set.uIcc_subset_uIcc_iff_le'
 
-theorem interval_subset_interval_right (h : x ∈ [[a, b]]) : [[x, b]] ⊆ [[a, b]] :=
-  interval_subset_interval h right_mem_interval
-#align set.interval_subset_interval_right Set.interval_subset_interval_right
+lemma uIcc_subset_uIcc_right (h : x ∈ [[a, b]]) : [[x, b]] ⊆ [[a, b]] :=
+  uIcc_subset_uIcc h right_mem_uIcc
+#align set.uIcc_subset_uIcc_right Set.uIcc_subset_uIcc_right
 
-theorem interval_subset_interval_left (h : x ∈ [[a, b]]) : [[a, x]] ⊆ [[a, b]] :=
-  interval_subset_interval left_mem_interval h
-#align set.interval_subset_interval_left Set.interval_subset_interval_left
+lemma uIcc_subset_uIcc_left (h : x ∈ [[a, b]]) : [[a, x]] ⊆ [[a, b]] :=
+  uIcc_subset_uIcc left_mem_uIcc h
+#align set.uIcc_subset_uIcc_left Set.uIcc_subset_uIcc_left
 
-theorem bdd_below_bdd_above_iff_subset_interval (s : Set α) :
+lemma bdd_below_bdd_above_iff_subset_uIcc (s : Set α) :
     BddBelow s ∧ BddAbove s ↔ ∃ a b, s ⊆ [[a, b]] :=
   bddBelow_bddAbove_iff_subset_Icc.trans
-    ⟨fun ⟨a, b, h⟩ => ⟨a, b, fun _ hx => Icc_subset_interval (h hx)⟩, fun ⟨_, _, h⟩ => ⟨_, _, h⟩⟩
-#align set.bdd_below_bdd_above_iff_subset_interval Set.bdd_below_bdd_above_iff_subset_interval
+    ⟨fun ⟨a, b, h⟩ => ⟨a, b, fun _ hx => Icc_subset_uIcc (h hx)⟩, fun ⟨_, _, h⟩ => ⟨_, _, h⟩⟩
+#align set.bdd_below_bdd_above_iff_subset_uIcc Set.bdd_below_bdd_above_iff_subset_uIcc
 
 end Lattice
 
@@ -170,22 +149,22 @@ section DistribLattice
 
 variable [DistribLattice α] {a a₁ a₂ b b₁ b₂ c x : α}
 
-theorem eq_of_mem_interval_of_mem_interval (ha : a ∈ [[b, c]]) (hb : b ∈ [[a, c]]) : a = b :=
+lemma eq_of_mem_uIcc_of_mem_uIcc (ha : a ∈ [[b, c]]) (hb : b ∈ [[a, c]]) : a = b :=
   eq_of_inf_eq_sup_eq (inf_congr_right ha.1 hb.1) <| sup_congr_right ha.2 hb.2
-#align set.eq_of_mem_interval_of_mem_interval Set.eq_of_mem_interval_of_mem_interval
+#align set.eq_of_mem_uIcc_of_mem_uIcc Set.eq_of_mem_uIcc_of_mem_uIcc
 
-theorem eq_of_mem_interval_of_mem_interval' : b ∈ [[a, c]] → c ∈ [[a, b]] → b = c := by
-  simpa only [interval_swap a] using eq_of_mem_interval_of_mem_interval
-#align set.eq_of_mem_interval_of_mem_interval' Set.eq_of_mem_interval_of_mem_interval'
+lemma eq_of_mem_uIcc_of_mem_uIcc' : b ∈ [[a, c]] → c ∈ [[a, b]] → b = c := by
+  simpa only [uIcc_comm a] using eq_of_mem_uIcc_of_mem_uIcc
+#align set.eq_of_mem_uIcc_of_mem_uIcc' Set.eq_of_mem_uIcc_of_mem_uIcc'
 
-theorem interval_injective_right (a : α) : Injective fun b => interval b a := fun b c h => by
+lemma uIcc_injective_right (a : α) : Injective fun b => uIcc b a := fun b c h => by
   rw [ext_iff] at h
-  exact eq_of_mem_interval_of_mem_interval ((h _).1 left_mem_interval) ((h _).2 left_mem_interval)
-#align set.interval_injective_right Set.interval_injective_right
+  exact eq_of_mem_uIcc_of_mem_uIcc ((h _).1 left_mem_uIcc) ((h _).2 left_mem_uIcc)
+#align set.uIcc_injective_right Set.uIcc_injective_right
 
-theorem interval_injective_left (a : α) : Injective (interval a) := by
-  simpa only [interval_swap] using interval_injective_right a
-#align set.interval_injective_left Set.interval_injective_left
+lemma uIcc_injective_left (a : α) : Injective (uIcc a) := by
+  simpa only [uIcc_comm] using uIcc_injective_right a
+#align set.uIcc_injective_left Set.uIcc_injective_left
 
 end DistribLattice
 
@@ -197,42 +176,39 @@ theorem Icc_min_max : Icc (min a b) (max a b) = [[a, b]] :=
   rfl
 #align set.Icc_min_max Set.Icc_min_max
 
-theorem interval_of_not_le (h : ¬a ≤ b) : [[a, b]] = Icc b a :=
-  interval_of_gt <| lt_of_not_ge h
-#align set.interval_of_not_le Set.interval_of_not_le
+lemma uIcc_of_not_le (h : ¬a ≤ b) : [[a, b]] = Icc b a := uIcc_of_gt $ lt_of_not_ge h
+#align set.uIcc_of_not_le Set.uIcc_of_not_le
+lemma uIcc_of_not_ge (h : ¬b ≤ a) : [[a, b]] = Icc a b := uIcc_of_lt $ lt_of_not_ge h
+#align set.uIcc_of_not_ge Set.uIcc_of_not_ge
 
-theorem interval_of_not_ge (h : ¬b ≤ a) : [[a, b]] = Icc a b :=
-  interval_of_lt <| lt_of_not_ge h
-#align set.interval_of_not_ge Set.interval_of_not_ge
+lemma uIcc_eq_union : [[a, b]] = Icc a b ∪ Icc b a := by rw [Icc_union_Icc', max_comm] <;> rfl
+#align set.uIcc_eq_union Set.uIcc_eq_union
 
-theorem interval_eq_union : [[a, b]] = Icc a b ∪ Icc b a := by rw [Icc_union_Icc', max_comm] <;> rfl
-#align set.interval_eq_union Set.interval_eq_union
+lemma mem_uIcc : a ∈ [[b, c]] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b := by simp [uIcc_eq_union]
+#align set.mem_uIcc Set.mem_uIcc
 
-theorem mem_interval : a ∈ [[b, c]] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b := by simp [interval_eq_union]
-#align set.mem_interval Set.mem_interval
-
-theorem not_mem_interval_of_lt (ha : c < a) (hb : c < b) : c ∉ [[a, b]] :=
+lemma not_mem_uIcc_of_lt (ha : c < a) (hb : c < b) : c ∉ [[a, b]] :=
   not_mem_Icc_of_lt <| lt_min_iff.mpr ⟨ha, hb⟩
-#align set.not_mem_interval_of_lt Set.not_mem_interval_of_lt
+#align set.not_mem_uIcc_of_lt Set.not_mem_uIcc_of_lt
 
-theorem not_mem_interval_of_gt (ha : a < c) (hb : b < c) : c ∉ [[a, b]] :=
+lemma not_mem_uIcc_of_gt (ha : a < c) (hb : b < c) : c ∉ [[a, b]] :=
   not_mem_Icc_of_gt <| max_lt_iff.mpr ⟨ha, hb⟩
-#align set.not_mem_interval_of_gt Set.not_mem_interval_of_gt
+#align set.not_mem_uIcc_of_gt Set.not_mem_uIcc_of_gt
 
-theorem interval_subset_interval_iff_le :
+lemma uIcc_subset_uIcc_iff_le :
     [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂ :=
-  interval_subset_interval_iff_le'
-#align set.interval_subset_interval_iff_le Set.interval_subset_interval_iff_le
+  uIcc_subset_uIcc_iff_le'
+#align set.uIcc_subset_uIcc_iff_le Set.uIcc_subset_uIcc_iff_le
 
 /-- A sort of triangle inequality. -/
-theorem interval_subset_interval_union_interval : [[a, c]] ⊆ [[a, b]] ∪ [[b, c]] := fun x => by
-  simp only [mem_interval, mem_union]
+lemma uIcc_subset_uIcc_union_uIcc : [[a, c]] ⊆ [[a, b]] ∪ [[b, c]] := fun x => by
+  simp only [mem_uIcc, mem_union]
   cases' le_total a c with h1 h1 <;>
   cases' le_total x b with h2 h2 <;>
   tauto
-#align set.interval_subset_interval_union_interval Set.interval_subset_interval_union_interval
+#align set.uIcc_subset_uIcc_union_uIcc Set.uIcc_subset_uIcc_union_uIcc
 
-theorem monotone_or_antitone_iff_interval :
+lemma monotone_or_antitone_iff_uIcc :
     Monotone f ∨ Antitone f ↔ ∀ a b c, c ∈ [[a, b]] → f c ∈ [[f a, f b]] := by
   constructor
   · rintro (hf | hf) a b c <;> simp_rw [← Icc_min_max, ← hf.map_min, ← hf.map_max]
@@ -240,117 +216,107 @@ theorem monotone_or_antitone_iff_interval :
   contrapose!
   rw [not_monotone_not_antitone_iff_exists_le_le]
   rintro ⟨a, b, c, hab, hbc, ⟨hfab, hfcb⟩ | ⟨hfba, hfbc⟩⟩
-  · exact ⟨a, c, b, Icc_subset_interval ⟨hab, hbc⟩, fun h => h.2.not_lt <| max_lt hfab hfcb⟩
-  · exact ⟨a, c, b, Icc_subset_interval ⟨hab, hbc⟩, fun h => h.1.not_lt <| lt_min hfba hfbc⟩
-#align set.monotone_or_antitone_iff_interval Set.monotone_or_antitone_iff_interval
+  · exact ⟨a, c, b, Icc_subset_uIcc ⟨hab, hbc⟩, fun h => h.2.not_lt <| max_lt hfab hfcb⟩
+  · exact ⟨a, c, b, Icc_subset_uIcc ⟨hab, hbc⟩, fun h => h.1.not_lt <| lt_min hfba hfbc⟩
+#align set.monotone_or_antitone_iff_uIcc Set.monotone_or_antitone_iff_uIcc
 
 -- Porting note: mathport expands the syntactic sugar `∀ a b c ∈ s` differently than Lean3
-theorem monotoneOn_or_antitoneOn_iff_interval :
+lemma monotoneOn_or_antitoneOn_iff_uIcc :
     MonotoneOn f s ∨ AntitoneOn f s ↔
       ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s) (c) (_ : c ∈ s), c ∈ [[a, b]] → f c ∈ [[f a, f b]] :=
-  by simp [monotoneOn_iff_monotone, antitoneOn_iff_antitone, monotone_or_antitone_iff_interval,
-    mem_interval]
-#align set.monotone_on_or_antitone_on_iff_interval Set.monotoneOn_or_antitoneOn_iff_interval
+  by simp [monotoneOn_iff_monotone, antitoneOn_iff_antitone, monotone_or_antitone_iff_uIcc,
+    mem_uIcc]
+#align set.monotone_on_or_antitone_on_iff_uIcc Set.monotoneOn_or_antitoneOn_iff_uIcc
 
--- Porting note: what should the naming scheme be here? This is a term, so should be `intervalOC`,
+-- Porting note: what should the naming scheme be here? This is a term, so should be `uIoc`,
 -- but we also want to match the `Ioc` convention.
-/-- The open-closed interval with unordered bounds. -/
-def intervalOC : α → α → Set α := fun a b => Ioc (min a b) (max a b)
-#align set.interval_oc Set.intervalOC
+/-- The open-closed uIcc with unordered bounds. -/
+def uIoc : α → α → Set α := fun a b => Ioc (min a b) (max a b)
+#align set.uIoc Set.uIoc
 
--- Porting note: removed `scoped[Interval]` temporarily before a workaround is found
+-- Porting note: removed `scoped[uIcc]` temporarily before a workaround is found
 -- Below is a capital iota
 /-- `Ι a b` denotes the open-closed interval with unordered bounds. Here, `Ι` is a capital iota,
 distinguished from a capital `i`. -/
-notation "Ι" => Set.intervalOC
-
-@[simp]
-theorem intervalOC_of_le (h : a ≤ b) : Ι a b = Ioc a b := by simp [intervalOC, h]
-#align set.interval_oc_of_le Set.intervalOC_of_le
+notation "Ι" => Set.uIoc
 
-@[simp]
-theorem intervalOC_of_lt (h : b < a) : Ι a b = Ioc b a := by simp [intervalOC, le_of_lt h]
-#align set.interval_oc_of_lt Set.intervalOC_of_lt
+@[simp] lemma uIoc_of_le (h : a ≤ b) : Ι a b = Ioc a b := by simp [uIoc, h]
+#align set.uIoc_of_le Set.uIoc_of_le
+@[simp] lemma uIoc_of_lt (h : b < a) : Ι a b = Ioc b a := by simp [uIoc, le_of_lt h]
+#align set.uIoc_of_lt Set.uIoc_of_lt
 
-theorem intervalOC_eq_union : Ι a b = Ioc a b ∪ Ioc b a := by
-  cases le_total a b <;> simp [intervalOC, *]
-#align set.interval_oc_eq_union Set.intervalOC_eq_union
+lemma uIoc_eq_union : Ι a b = Ioc a b ∪ Ioc b a := by
+  cases le_total a b <;> simp [uIoc, *]
+#align set.uIoc_eq_union Set.uIoc_eq_union
 
-theorem mem_intervalOC : a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b := by
-  rw [intervalOC_eq_union, mem_union, mem_Ioc, mem_Ioc]
-#align set.mem_interval_oc Set.mem_intervalOC
+lemma mem_uIoc : a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b := by
+  rw [uIoc_eq_union, mem_union, mem_Ioc, mem_Ioc]
+#align set.mem_uIoc Set.mem_uIoc
 
-theorem not_mem_intervalOC : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a := by
-  simp only [intervalOC_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]
+lemma not_mem_uIoc : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a := by
+  simp only [uIoc_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]
   tauto
-#align set.not_mem_interval_oc Set.not_mem_intervalOC
+#align set.not_mem_uIoc Set.not_mem_uIoc
 
-@[simp]
-theorem left_mem_intervalOC : a ∈ Ι a b ↔ b < a := by simp [mem_intervalOC]
-#align set.left_mem_interval_oc Set.left_mem_intervalOC
-
-@[simp]
-theorem right_mem_intervalOC : b ∈ Ι a b ↔ a < b := by simp [mem_intervalOC]
-#align set.right_mem_interval_oc Set.right_mem_intervalOC
+@[simp] lemma left_mem_uIoc : a ∈ Ι a b ↔ b < a := by simp [mem_uIoc]
+#align set.left_mem_uIoc Set.left_mem_uIoc
+@[simp] lemma right_mem_uIoc : b ∈ Ι a b ↔ a < b := by simp [mem_uIoc]
+#align set.right_mem_uIoc Set.right_mem_uIoc
 
-theorem forall_intervalOC_iff {P : α → Prop} :
+lemma forall_uIoc_iff {P : α → Prop} :
     (∀ x ∈ Ι a b, P x) ↔ (∀ x ∈ Ioc a b, P x) ∧ ∀ x ∈ Ioc b a, P x := by
-  simp only [intervalOC_eq_union, mem_union, or_imp, forall_and]
-#align set.forall_interval_oc_iff Set.forall_intervalOC_iff
+  simp only [uIoc_eq_union, mem_union, or_imp, forall_and]
+#align set.forall_uIoc_iff Set.forall_uIoc_iff
 
-theorem intervalOC_subset_intervalOC_of_interval_subset_interval {a b c d : α}
+lemma uIoc_subset_uIoc_of_uIcc_subset_uIcc {a b c d : α}
     (h : [[a, b]] ⊆ [[c, d]]) : Ι a b ⊆ Ι c d :=
-  Ioc_subset_Ioc (interval_subset_interval_iff_le.1 h).1 (interval_subset_interval_iff_le.1 h).2
-#align set.interval_oc_subset_interval_oc_of_interval_subset_interval Set.intervalOC_subset_intervalOC_of_interval_subset_interval
-
-theorem intervalOC_swap (a b : α) : Ι a b = Ι b a := by
-  simp only [intervalOC, min_comm a b, max_comm a b]
-#align set.interval_oc_swap Set.intervalOC_swap
+  Ioc_subset_Ioc (uIcc_subset_uIcc_iff_le.1 h).1 (uIcc_subset_uIcc_iff_le.1 h).2
+#align set.uIoc_subset_uIoc_of_uIcc_subset_uIcc Set.uIoc_subset_uIoc_of_uIcc_subset_uIcc
 
-theorem Ioc_subset_intervalOC : Ioc a b ⊆ Ι a b :=
-  Ioc_subset_Ioc (min_le_left _ _) (le_max_right _ _)
-#align set.Ioc_subset_interval_oc Set.Ioc_subset_intervalOC
+lemma uIoc_comm (a b : α) : Ι a b = Ι b a := by simp only [uIoc, min_comm a b, max_comm a b]
+#align set.uIoc_comm Set.uIoc_comm
 
-theorem Ioc_subset_intervalOC' : Ioc a b ⊆ Ι b a :=
-  Ioc_subset_Ioc (min_le_right _ _) (le_max_left _ _)
-#align set.Ioc_subset_interval_oc' Set.Ioc_subset_intervalOC'
+lemma Ioc_subset_uIoc : Ioc a b ⊆ Ι a b := Ioc_subset_Ioc (min_le_left _ _) (le_max_right _ _)
+#align set.Ioc_subset_uIoc Set.Ioc_subset_uIoc
+lemma Ioc_subset_uIoc' : Ioc a b ⊆ Ι b a := Ioc_subset_Ioc (min_le_right _ _) (le_max_left _ _)
+#align set.Ioc_subset_uIoc' Set.Ioc_subset_uIoc'
 
-theorem eq_of_mem_intervalOC_of_mem_intervalOC : a ∈ Ι b c → b ∈ Ι a c → a = b := by
-  simp_rw [mem_intervalOC]; rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩) <;> apply le_antisymm <;>
+lemma eq_of_mem_uIoc_of_mem_uIoc : a ∈ Ι b c → b ∈ Ι a c → a = b := by
+  simp_rw [mem_uIoc]; rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩) <;> apply le_antisymm <;>
     first |assumption|exact le_of_lt ‹_›|exact le_trans ‹_› (le_of_lt ‹_›)
-#align set.eq_of_mem_interval_oc_of_mem_interval_oc Set.eq_of_mem_intervalOC_of_mem_intervalOC
+#align set.eq_of_mem_uIoc_of_mem_uIoc Set.eq_of_mem_uIoc_of_mem_uIoc
 
-theorem eq_of_mem_intervalOC_of_mem_intervalOC' : b ∈ Ι a c → c ∈ Ι a b → b = c := by
-  simpa only [intervalOC_swap a] using eq_of_mem_intervalOC_of_mem_intervalOC
-#align set.eq_of_mem_interval_oc_of_mem_interval_oc' Set.eq_of_mem_intervalOC_of_mem_intervalOC'
+lemma eq_of_mem_uIoc_of_mem_uIoc' : b ∈ Ι a c → c ∈ Ι a b → b = c := by
+  simpa only [uIoc_comm a] using eq_of_mem_uIoc_of_mem_uIoc
+#align set.eq_of_mem_uIoc_of_mem_uIoc' Set.eq_of_mem_uIoc_of_mem_uIoc'
 
-theorem eq_of_not_mem_intervalOC_of_not_mem_intervalOC (ha : a ≤ c) (hb : b ≤ c) :
+lemma eq_of_not_mem_uIoc_of_not_mem_uIoc (ha : a ≤ c) (hb : b ≤ c) :
     a ∉ Ι b c → b ∉ Ι a c → a = b := by
-  simp_rw [not_mem_intervalOC]
+  simp_rw [not_mem_uIoc]
   rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩) <;>
       apply le_antisymm <;>
     first |assumption|exact le_of_lt ‹_›|
     exact absurd hb (not_le_of_lt ‹c < b›)|exact absurd ha (not_le_of_lt ‹c < a›)
-#align set.eq_of_not_mem_interval_oc_of_not_mem_interval_oc Set.eq_of_not_mem_intervalOC_of_not_mem_intervalOC
+#align set.eq_of_not_mem_uIoc_of_not_mem_uIoc Set.eq_of_not_mem_uIoc_of_not_mem_uIoc
 
-theorem intervalOC_injective_right (a : α) : Injective fun b => Ι b a := by
+lemma uIoc_injective_right (a : α) : Injective fun b => Ι b a := by
   rintro b c h
   rw [ext_iff] at h
   obtain ha | ha := le_or_lt b a
   · have hb := (h b).not
-    simp only [ha, left_mem_intervalOC, not_lt, true_iff_iff, not_mem_intervalOC, ← not_le,
+    simp only [ha, left_mem_uIoc, not_lt, true_iff_iff, not_mem_uIoc, ← not_le,
       and_true_iff, not_true, false_and_iff, not_false_iff, true_iff_iff, or_false_iff] at hb
     refine' hb.eq_of_not_lt fun hc => _
     simpa [ha, and_iff_right hc, ← @not_le _ _ _ a, iff_not_self, -not_le] using h c
   · refine'
-      eq_of_mem_intervalOC_of_mem_intervalOC ((h _).1 <| left_mem_intervalOC.2 ha)
-        ((h _).2 <| left_mem_intervalOC.2 <| ha.trans_le _)
-    simpa [ha, ha.not_le, mem_intervalOC] using h b
-#align set.interval_oc_injective_right Set.intervalOC_injective_right
-
-theorem intervalOC_injective_left (a : α) : Injective (Ι a) := by
-  simpa only [intervalOC_swap] using intervalOC_injective_right a
-#align set.interval_oc_injective_left Set.intervalOC_injective_left
+      eq_of_mem_uIoc_of_mem_uIoc ((h _).1 <| left_mem_uIoc.2 ha)
+        ((h _).2 <| left_mem_uIoc.2 <| ha.trans_le _)
+    simpa [ha, ha.not_le, mem_uIoc] using h b
+#align set.uIoc_injective_right Set.uIoc_injective_right
+
+lemma uIoc_injective_left (a : α) : Injective (Ι a) := by
+  simpa only [uIoc_comm] using uIoc_injective_right a
+#align set.uIoc_injective_left Set.uIoc_injective_left
 
 end LinearOrder

chore: the style linter shouldn't complain about long #align lines (#1643)

54af0498

Diff

@@ -301,9 +301,7 @@ theorem forall_intervalOC_iff {P : α → Prop} :
 theorem intervalOC_subset_intervalOC_of_interval_subset_interval {a b c d : α}
     (h : [[a, b]] ⊆ [[c, d]]) : Ι a b ⊆ Ι c d :=
   Ioc_subset_Ioc (interval_subset_interval_iff_le.1 h).1 (interval_subset_interval_iff_le.1 h).2
-#align
-  set.interval_oc_subset_interval_oc_of_interval_subset_interval
-  Set.intervalOC_subset_intervalOC_of_interval_subset_interval
+#align set.interval_oc_subset_interval_oc_of_interval_subset_interval Set.intervalOC_subset_intervalOC_of_interval_subset_interval
 
 theorem intervalOC_swap (a b : α) : Ι a b = Ι b a := by
   simp only [intervalOC, min_comm a b, max_comm a b]
@@ -333,9 +331,7 @@ theorem eq_of_not_mem_intervalOC_of_not_mem_intervalOC (ha : a ≤ c) (hb : b 
       apply le_antisymm <;>
     first |assumption|exact le_of_lt ‹_›|
     exact absurd hb (not_le_of_lt ‹c < b›)|exact absurd ha (not_le_of_lt ‹c < a›)
-#align
-  set.eq_of_not_mem_interval_oc_of_not_mem_interval_oc
-  Set.eq_of_not_mem_intervalOC_of_not_mem_intervalOC
+#align set.eq_of_not_mem_interval_oc_of_not_mem_interval_oc Set.eq_of_not_mem_intervalOC_of_not_mem_intervalOC
 
 theorem intervalOC_injective_right (a : α) : Injective fun b => Ι b a := by
   rintro b c h

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

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

72b23bd4

Diff

@@ -295,7 +295,7 @@ theorem right_mem_intervalOC : b ∈ Ι a b ↔ a < b := by simp [mem_intervalOC
 
 theorem forall_intervalOC_iff {P : α → Prop} :
     (∀ x ∈ Ι a b, P x) ↔ (∀ x ∈ Ioc a b, P x) ∧ ∀ x ∈ Ioc b a, P x := by
-  simp only [intervalOC_eq_union, mem_union, or_imp, forall_and, iff_self]
+  simp only [intervalOC_eq_union, mem_union, or_imp, forall_and]
 #align set.forall_interval_oc_iff Set.forall_intervalOC_iff
 
 theorem intervalOC_subset_intervalOC_of_interval_subset_interval {a b c d : α}

fix: ignore isImplementationDetail ldecls in Tauto.distribNot (#1317)

Fixes a bug where tauto could try to work on a recursive auxiliary LocalDecl, potentially causing an error about well-founded recursion.
Updates Data/Set/Intervals/UnorderedInterval.lean to use tauto, as per TODOs. The not_mem_intervalOC theorem is where I noticed the bug.
Adds a test case isolated from not_mem_intervalOC.

0b1fd78b

Diff

@@ -11,6 +11,7 @@ Authors: Zhouhang Zhou
 import Mathlib.Order.Bounds.Basic
 import Mathlib.Data.Set.Intervals.Basic
 import Mathlib.Tactic.ScopedNS
+import Mathlib.Tactic.Tauto
 
 /-!
 # Intervals without endpoints ordering
@@ -228,8 +229,7 @@ theorem interval_subset_interval_union_interval : [[a, c]] ⊆ [[a, b]] ∪ [[b,
   simp only [mem_interval, mem_union]
   cases' le_total a c with h1 h1 <;>
   cases' le_total x b with h2 h2 <;>
-  -- Porting note: restore `tauto`
-  aesop
+  tauto
 #align set.interval_subset_interval_union_interval Set.interval_subset_interval_union_interval
 
 theorem monotone_or_antitone_iff_interval :
@@ -281,25 +281,8 @@ theorem mem_intervalOC : a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤
 #align set.mem_interval_oc Set.mem_intervalOC
 
 theorem not_mem_intervalOC : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a := by
-  -- Porting note: restore `tauto` once it's ported
-  -- simp only [interval_oc_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]
-  -- tauto
-  rw [intervalOC_eq_union, mem_union, mem_Ioc, mem_Ioc]
-  push_neg
-  constructor
-  · rintro ⟨h1, h2⟩
-    by_cases b < a
-    case pos _ =>
-      apply Or.intro_right
-      exact ⟨h1 h, h⟩
-    case neg _ =>
-      rw [not_lt] at h
-      rw [← not_imp_not, not_lt, not_lt] at h2
-      apply Or.intro_left
-      exact ⟨h, h2 h⟩
-  · intro h
-    rw [← iff_def, iff_iff_and_or_not_and_not, and_comm]
-    rwa [← not_lt, ← not_lt, or_comm] at h
+  simp only [intervalOC_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]
+  tauto
 #align set.not_mem_interval_oc Set.not_mem_intervalOC
 
 @[simp]

chore: fix casing per naming scheme (#1183)

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

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

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

71723d8b

Diff

@@ -52,7 +52,7 @@ section Lattice
 variable [Lattice α] {a a₁ a₂ b b₁ b₂ c x : α}
 
 /-- `interval a b` is the set of elements lying between `a` and `b`, with `a` and `b` included.
-Note that we define it more generally in a lattice as `set.Icc (a ⊓ b) (a ⊔ b)`. In a product type,
+Note that we define it more generally in a lattice as `Set.Icc (a ⊓ b) (a ⊔ b)`. In a product type,
 `interval` corresponds to the bounding box of the two elements. -/
 def interval (a b : α) : Set α :=
   Icc (a ⊓ b) (a ⊔ b)