File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

full_name: Set.uIcc
code: /-- `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,
`uIcc` corresponds to the bounding box of the two elements. -/
def uIcc (a b : α) : Set α 
goal: Set α

full_name: Interval.«_aux_Mathlib_Order_Interval_Set_UnorderedInterval___macroRules_Interval_term[[_,_]]_1»
code: /-- `[[a, b]]` denotes the set of elements lying between `a` and `b`, inclusive. -/
scoped[Interval] notation "[[" a ", " b "]]" => Set.uIcc a b
goal: Lean.Macro

full_name: Interval._aux_Mathlib_Order_Interval_Set_UnorderedInterval___unexpand_Set_uIcc_1
code: /-- `[[a, b]]` denotes the set of elements lying between `a` and `b`, inclusive. -/
scoped[Interval] notation "[[" a ", " b "]]" => Set.uIcc a b
goal: Lean.PrettyPrinter.Unexpander

full_name: Set.dual_uIcc
code: @[simp] lemma dual_uIcc (a b : α) : [[toDual a, toDual b]] = ofDual ⁻¹' [[a, b]] 
goal: Set.uIcc (OrderDual.toDual a) (OrderDual.toDual b) = ⇑OrderDual.ofDual ⁻¹' Set.uIcc a b

full_name: Set.uIcc_of_le
code: @[simp]
lemma uIcc_of_le (h : a ≤ b) : [[a, b]] = Icc a b 
goal: Set.uIcc a b = Set.Icc a b

full_name: Set.uIcc_of_ge
code: @[simp]
lemma uIcc_of_ge (h : b ≤ a) : [[a, b]] = Icc b a 
goal: Set.uIcc a b = Set.Icc b a

full_name: Set.uIcc_comm
code: lemma uIcc_comm (a b : α) : [[a, b]] = [[b, a]] 
goal: Set.uIcc a b = Set.uIcc b a

full_name: Set.uIcc_of_lt
code: lemma uIcc_of_lt (h : a < b) : [[a, b]] = Icc a b 
goal: Set.uIcc a b = Set.Icc a b

full_name: Set.uIcc_of_gt
code: lemma uIcc_of_gt (h : b < a) : [[a, b]] = Icc b a 
goal: Set.uIcc a b = Set.Icc b a

full_name: Set.uIcc_self
code: lemma uIcc_self : [[a, a]] = {a} 
goal: Set.uIcc a a = {a}

full_name: Set.nonempty_uIcc
code: @[simp] lemma nonempty_uIcc : [[a, b]].Nonempty 
goal: (Set.uIcc a b).Nonempty

full_name: Set.Icc_subset_uIcc
code: lemma Icc_subset_uIcc : Icc a b ⊆ [[a, b]] 
goal: Set.Icc a b ⊆ Set.uIcc a b

full_name: Set.Icc_subset_uIcc'
code: lemma Icc_subset_uIcc' : Icc b a ⊆ [[a, b]] 
goal: Set.Icc b a ⊆ Set.uIcc a b

full_name: Set.left_mem_uIcc
code: @[simp] lemma left_mem_uIcc : a ∈ [[a, b]] 
goal: a ∈ Set.uIcc a b

full_name: Set.right_mem_uIcc
code: @[simp] lemma right_mem_uIcc : b ∈ [[a, b]] 
goal: b ∈ Set.uIcc a b

full_name: Set.mem_uIcc_of_le
code: lemma mem_uIcc_of_le (ha : a ≤ x) (hb : x ≤ b) : x ∈ [[a, b]] 
goal: x ∈ Set.uIcc a b

full_name: Set.mem_uIcc_of_ge
code: lemma mem_uIcc_of_ge (hb : b ≤ x) (ha : x ≤ a) : x ∈ [[a, b]] 
goal: x ∈ Set.uIcc a b

full_name: Set.uIcc_subset_uIcc
code: lemma uIcc_subset_uIcc (h₁ : a₁ ∈ [[a₂, b₂]]) (h₂ : b₁ ∈ [[a₂, b₂]]) :
    [[a₁, b₁]] ⊆ [[a₂, b₂]] 
goal: Set.uIcc a₁ b₁ ⊆ Set.uIcc a₂ b₂

full_name: Set.uIcc_subset_Icc
code: lemma uIcc_subset_Icc (ha : a₁ ∈ Icc a₂ b₂) (hb : b₁ ∈ Icc a₂ b₂) :
    [[a₁, b₁]] ⊆ Icc a₂ b₂ 
goal: Set.uIcc a₁ b₁ ⊆ Set.Icc a₂ b₂

full_name: Set.uIcc_subset_uIcc_iff_mem
code: lemma uIcc_subset_uIcc_iff_mem :
    [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₁ ∈ [[a₂, b₂]] ∧ b₁ ∈ [[a₂, b₂]] 
goal: Set.uIcc a₁ b₁ ⊆ Set.uIcc a₂ b₂ ↔ a₁ ∈ Set.uIcc a₂ b₂ ∧ b₁ ∈ Set.uIcc a₂ b₂

full_name: Set.uIcc_subset_uIcc_iff_le'
code: lemma uIcc_subset_uIcc_iff_le' :
    [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂ 
goal: Set.uIcc a₁ b₁ ⊆ Set.uIcc a₂ b₂ ↔ a₂ ⊓ b₂ ≤ a₁ ⊓ b₁ ∧ a₁ ⊔ b₁ ≤ a₂ ⊔ b₂

full_name: Set.uIcc_subset_uIcc_right
code: lemma uIcc_subset_uIcc_right (h : x ∈ [[a, b]]) : [[x, b]] ⊆ [[a, b]] 
goal: Set.uIcc x b ⊆ Set.uIcc a b

full_name: Set.uIcc_subset_uIcc_left
code: lemma uIcc_subset_uIcc_left (h : x ∈ [[a, b]]) : [[a, x]] ⊆ [[a, b]] 
goal: Set.uIcc a x ⊆ Set.uIcc a b

full_name: Set.bdd_below_bdd_above_iff_subset_uIcc
code: lemma bdd_below_bdd_above_iff_subset_uIcc (s : Set α) :
    BddBelow s ∧ BddAbove s ↔ ∃ a b, s ⊆ [[a, b]] 
goal: BddBelow s ∧ BddAbove s ↔ ∃ a b, s ⊆ Set.uIcc a b

full_name: Set.uIcc_prod_uIcc
code: @[simp]
theorem uIcc_prod_uIcc (a₁ a₂ : α) (b₁ b₂ : β) :
    [[a₁, a₂]] ×ˢ [[b₁, b₂]] = [[(a₁, b₁), (a₂, b₂)]] 
goal: Set.uIcc a₁ a₂ ×ˢ Set.uIcc b₁ b₂ = Set.uIcc (a₁, b₁) (a₂, b₂)

full_name: Set.uIcc_prod_eq
code: theorem uIcc_prod_eq (a b : α × β) : [[a, b]] = [[a.1, b.1]] ×ˢ [[a.2, b.2]] 
goal: Set.uIcc a b = Set.uIcc a.1 b.1 ×ˢ Set.uIcc a.2 b.2

full_name: Set.eq_of_mem_uIcc_of_mem_uIcc
code: lemma eq_of_mem_uIcc_of_mem_uIcc (ha : a ∈ [[b, c]]) (hb : b ∈ [[a, c]]) : a = b 
goal: a = b

full_name: Set.eq_of_mem_uIcc_of_mem_uIcc'
code: lemma eq_of_mem_uIcc_of_mem_uIcc' : b ∈ [[a, c]] → c ∈ [[a, b]] → b = c 
goal: b ∈ Set.uIcc a c → c ∈ Set.uIcc a b → b = c

full_name: Set.uIcc_injective_right
code: lemma uIcc_injective_right (a : α) : Injective fun b => uIcc b a 
goal: Function.Injective fun b => Set.uIcc b a

full_name: Set.uIcc_injective_left
code: lemma uIcc_injective_left (a : α) : Injective (uIcc a) 
goal: Function.Injective (Set.uIcc a)

full_name: MonotoneOn.mapsTo_uIcc
code: lemma _root_.MonotoneOn.mapsTo_uIcc (hf : MonotoneOn f (uIcc a b)) :
    MapsTo f (uIcc a b) (uIcc (f a) (f b)) 
goal: Set.MapsTo f (Set.uIcc a b) (Set.uIcc (f a) (f b))

full_name: AntitoneOn.mapsTo_uIcc
code: lemma _root_.AntitoneOn.mapsTo_uIcc (hf : AntitoneOn f (uIcc a b)) :
    MapsTo f (uIcc a b) (uIcc (f a) (f b)) 
goal: Set.MapsTo f (Set.uIcc a b) (Set.uIcc (f a) (f b))

full_name: Monotone.mapsTo_uIcc
code: lemma _root_.Monotone.mapsTo_uIcc (hf : Monotone f) : MapsTo f (uIcc a b) (uIcc (f a) (f b)) 
goal: Set.MapsTo f (Set.uIcc a b) (Set.uIcc (f a) (f b))

full_name: Antitone.mapsTo_uIcc
code: lemma _root_.Antitone.mapsTo_uIcc (hf : Antitone f) : MapsTo f (uIcc a b) (uIcc (f a) (f b)) 
goal: Set.MapsTo f (Set.uIcc a b) (Set.uIcc (f a) (f b))

full_name: MonotoneOn.image_uIcc_subset
code: lemma _root_.MonotoneOn.image_uIcc_subset (hf : MonotoneOn f (uIcc a b)) :
    f '' uIcc a b ⊆ uIcc (f a) (f b) 
goal: f '' Set.uIcc a b ⊆ Set.uIcc (f a) (f b)

full_name: AntitoneOn.image_uIcc_subset
code: lemma _root_.AntitoneOn.image_uIcc_subset (hf : AntitoneOn f (uIcc a b)) :
    f '' uIcc a b ⊆ uIcc (f a) (f b) 
goal: f '' Set.uIcc a b ⊆ Set.uIcc (f a) (f b)

full_name: Monotone.image_uIcc_subset
code: lemma _root_.Monotone.image_uIcc_subset (hf : Monotone f) : f '' uIcc a b ⊆ uIcc (f a) (f b) 
goal: f '' Set.uIcc a b ⊆ Set.uIcc (f a) (f b)

full_name: Antitone.image_uIcc_subset
code: lemma _root_.Antitone.image_uIcc_subset (hf : Antitone f) : f '' uIcc a b ⊆ uIcc (f a) (f b) 
goal: f '' Set.uIcc a b ⊆ Set.uIcc (f a) (f b)

full_name: Set.Icc_min_max
code: theorem Icc_min_max : Icc (min a b) (max a b) = [[a, b]] 
goal: Set.Icc (min a b) (max a b) = Set.uIcc a b

full_name: Set.uIcc_of_not_le
code: lemma uIcc_of_not_le (h : ¬a ≤ b) : [[a, b]] = Icc b a 
goal: Set.uIcc a b = Set.Icc b a

full_name: Set.uIcc_of_not_ge
code: lemma uIcc_of_not_ge (h : ¬b ≤ a) : [[a, b]] = Icc a b 
goal: Set.uIcc a b = Set.Icc a b

full_name: Set.uIcc_eq_union
code: lemma uIcc_eq_union : [[a, b]] = Icc a b ∪ Icc b a 
goal: Set.uIcc a b = Set.Icc a b ∪ Set.Icc b a

full_name: Set.mem_uIcc
code: lemma mem_uIcc : a ∈ [[b, c]] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b 
goal: a ∈ Set.uIcc b c ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b

full_name: Set.not_mem_uIcc_of_lt
code: lemma not_mem_uIcc_of_lt (ha : c < a) (hb : c < b) : c ∉ [[a, b]] 
goal: c ∉ Set.uIcc a b

full_name: Set.not_mem_uIcc_of_gt
code: lemma not_mem_uIcc_of_gt (ha : a < c) (hb : b < c) : c ∉ [[a, b]] 
goal: c ∉ Set.uIcc a b

full_name: Set.uIcc_subset_uIcc_iff_le
code: lemma uIcc_subset_uIcc_iff_le :
    [[a₁, b₁]] ⊆ [[a₂, b₂]] ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂ 
goal: Set.uIcc a₁ b₁ ⊆ Set.uIcc a₂ b₂ ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂

full_name: Set.uIcc_subset_uIcc_union_uIcc
code: /-- A sort of triangle inequality. -/
lemma uIcc_subset_uIcc_union_uIcc : [[a, c]] ⊆ [[a, b]] ∪ [[b, c]] 
goal: Set.uIcc a c ⊆ Set.uIcc a b ∪ Set.uIcc b c

full_name: Set.monotone_or_antitone_iff_uIcc
code: lemma monotone_or_antitone_iff_uIcc :
    Monotone f ∨ Antitone f ↔ ∀ a b c, c ∈ [[a, b]] → f c ∈ [[f a, f b]] 
goal: Monotone f ∨ Antitone f ↔ ∀ (a b c : α), c ∈ Set.uIcc a b → f c ∈ Set.uIcc (f a) (f b)

full_name: Set.monotoneOn_or_antitoneOn_iff_uIcc
code: lemma monotoneOn_or_antitoneOn_iff_uIcc :
    MonotoneOn f s ∨ AntitoneOn f s ↔
      ∀ᵉ (a ∈ s) (b ∈ s) (c ∈ s), c ∈ [[a, b]] → f c ∈ [[f a, f b]] 
goal: MonotoneOn f s ∨ AntitoneOn f s ↔ ∀ a ∈ s, ∀ b ∈ s, ∀ c ∈ s, c ∈ Set.uIcc a b → f c ∈ Set.uIcc (f a) (f b)

full_name: Set.uIoc
code: /-- The open-closed uIcc with unordered bounds. -/
def uIoc : α → α → Set α 
goal: α → α → Set α

full_name: Set._aux_Mathlib_Order_Interval_Set_UnorderedInterval___macroRules_Set_termΙ_1
code: /-- `Ι a b` denotes the open-closed interval with unordered bounds. Here, `Ι` is a capital iota,
distinguished from a capital `i`. -/
notation "Ι" => Set.uIoc
goal: Lean.Macro

full_name: Set._aux_Mathlib_Order_Interval_Set_UnorderedInterval___unexpand_Set_uIoc_1
code: /-- `Ι a b` denotes the open-closed interval with unordered bounds. Here, `Ι` is a capital iota,
distinguished from a capital `i`. -/
notation "Ι" => Set.uIoc
goal: Lean.PrettyPrinter.Unexpander

full_name: Set.uIoc_of_le
code: @[simp] lemma uIoc_of_le (h : a ≤ b) : Ι a b = Ioc a b 
goal: Ι a b = Set.Ioc a b

full_name: Set.uIoc_of_ge
code: @[simp] lemma uIoc_of_ge (h : b ≤ a) : Ι a b = Ioc b a 
goal: Ι a b = Set.Ioc b a

full_name: Set.uIoc_eq_union
code: lemma uIoc_eq_union : Ι a b = Ioc a b ∪ Ioc b a 
goal: Ι a b = Set.Ioc a b ∪ Set.Ioc b a

full_name: Set.mem_uIoc
code: lemma mem_uIoc : a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b 
goal: a ∈ Ι b c ↔ b < a ∧ a ≤ c ∨ c < a ∧ a ≤ b

full_name: Set.not_mem_uIoc
code: lemma not_mem_uIoc : a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a 
goal: a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a

full_name: Set.left_mem_uIoc
code: @[simp] lemma left_mem_uIoc : a ∈ Ι a b ↔ b < a 
goal: a ∈ Ι a b ↔ b < a

full_name: Set.right_mem_uIoc
code: @[simp] lemma right_mem_uIoc : b ∈ Ι a b ↔ a < b 
goal: b ∈ Ι a b ↔ a < b

full_name: Set.forall_uIoc_iff
code: lemma forall_uIoc_iff {P : α → Prop} :
    (∀ x ∈ Ι a b, P x) ↔ (∀ x ∈ Ioc a b, P x) ∧ ∀ x ∈ Ioc b a, P x 
goal: (∀ x ∈ Ι a b, P x) ↔ (∀ x ∈ Set.Ioc a b, P x) ∧ ∀ x ∈ Set.Ioc b a, P x

full_name: Set.uIoc_subset_uIoc_of_uIcc_subset_uIcc
code: lemma uIoc_subset_uIoc_of_uIcc_subset_uIcc {a b c d : α}
    (h : [[a, b]] ⊆ [[c, d]]) : Ι a b ⊆ Ι c d 
goal: Ι a b ⊆ Ι c d

full_name: Set.uIoc_comm
code: lemma uIoc_comm (a b : α) : Ι a b = Ι b a 
goal: Ι a b = Ι b a

full_name: Set.Ioc_subset_uIoc
code: lemma Ioc_subset_uIoc : Ioc a b ⊆ Ι a b 
goal: Set.Ioc a b ⊆ Ι a b

full_name: Set.Ioc_subset_uIoc'
code: lemma Ioc_subset_uIoc' : Ioc a b ⊆ Ι b a 
goal: Set.Ioc a b ⊆ Ι b a

full_name: Set.uIoc_subset_uIcc
code: lemma uIoc_subset_uIcc : Ι a b ⊆ uIcc a b 
goal: Ι a b ⊆ Set.uIcc a b

full_name: Set.eq_of_mem_uIoc_of_mem_uIoc
code: lemma eq_of_mem_uIoc_of_mem_uIoc : a ∈ Ι b c → b ∈ Ι a c → a = b 
goal: a ∈ Ι b c → b ∈ Ι a c → a = b

full_name: Set.eq_of_mem_uIoc_of_mem_uIoc'
code: lemma eq_of_mem_uIoc_of_mem_uIoc' : b ∈ Ι a c → c ∈ Ι a b → b = c 
goal: b ∈ Ι a c → c ∈ Ι a b → b = c

full_name: Set.eq_of_not_mem_uIoc_of_not_mem_uIoc
code: lemma eq_of_not_mem_uIoc_of_not_mem_uIoc (ha : a ≤ c) (hb : b ≤ c) :
    a ∉ Ι b c → b ∉ Ι a c → a = b 
goal: a ∉ Ι b c → b ∉ Ι a c → a = b

full_name: Set.uIoc_injective_right
code: lemma uIoc_injective_right (a : α) : Injective fun b => Ι b a 
goal: Function.Injective fun b => Ι b a

full_name: Set.uIoc_injective_left
code: lemma uIoc_injective_left (a : α) : Injective (Ι a) 
goal: Function.Injective (Ι a)