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

full_name: Set.Ioo
code: /-- Left-open right-open interval -/
def Ioo (a b : α) 
goal: Set α

full_name: Set.Ico
code: /-- Left-closed right-open interval -/
def Ico (a b : α) 
goal: Set α

full_name: Set.Iio
code: /-- Left-infinite right-open interval -/
def Iio (a : α) 
goal: Set α

full_name: Set.Icc
code: /-- Left-closed right-closed interval -/
def Icc (a b : α) 
goal: Set α

full_name: Set.Iic
code: /-- Left-infinite right-closed interval -/
def Iic (b : α) 
goal: Set α

full_name: Set.Ioc
code: /-- Left-open right-closed interval -/
def Ioc (a b : α) 
goal: Set α

full_name: Set.Ici
code: /-- Left-closed right-infinite interval -/
def Ici (a : α) 
goal: Set α

full_name: Set.Ioi
code: /-- Left-open right-infinite interval -/
def Ioi (a : α) 
goal: Set α

full_name: Set.Ioo_def
code: theorem Ioo_def (a b : α) : { x | a < x ∧ x < b } = Ioo a b 
goal: {x | a < x ∧ x < b} = Set.Ioo a b

full_name: Set.Ico_def
code: theorem Ico_def (a b : α) : { x | a ≤ x ∧ x < b } = Ico a b 
goal: {x | a ≤ x ∧ x < b} = Set.Ico a b

full_name: Set.Iio_def
code: theorem Iio_def (a : α) : { x | x < a } = Iio a 
goal: {x | x < a} = Set.Iio a

full_name: Set.Icc_def
code: theorem Icc_def (a b : α) : { x | a ≤ x ∧ x ≤ b } = Icc a b 
goal: {x | a ≤ x ∧ x ≤ b} = Set.Icc a b

full_name: Set.Iic_def
code: theorem Iic_def (b : α) : { x | x ≤ b } = Iic b 
goal: {x | x ≤ b} = Set.Iic b

full_name: Set.Ioc_def
code: theorem Ioc_def (a b : α) : { x | a < x ∧ x ≤ b } = Ioc a b 
goal: {x | a < x ∧ x ≤ b} = Set.Ioc a b

full_name: Set.Ici_def
code: theorem Ici_def (a : α) : { x | a ≤ x } = Ici a 
goal: {x | a ≤ x} = Set.Ici a

full_name: Set.Ioi_def
code: theorem Ioi_def (a : α) : { x | a < x } = Ioi a 
goal: {x | a < x} = Set.Ioi a

full_name: Set.mem_Ioo
code: @[simp]
theorem mem_Ioo : x ∈ Ioo a b ↔ a < x ∧ x < b 
goal: x ∈ Set.Ioo a b ↔ a < x ∧ x < b

full_name: Set.mem_Ico
code: @[simp]
theorem mem_Ico : x ∈ Ico a b ↔ a ≤ x ∧ x < b 
goal: x ∈ Set.Ico a b ↔ a ≤ x ∧ x < b

full_name: Set.mem_Iio
code: @[simp]
theorem mem_Iio : x ∈ Iio b ↔ x < b 
goal: x ∈ Set.Iio b ↔ x < b

full_name: Set.mem_Icc
code: @[simp]
theorem mem_Icc : x ∈ Icc a b ↔ a ≤ x ∧ x ≤ b 
goal: x ∈ Set.Icc a b ↔ a ≤ x ∧ x ≤ b

full_name: Set.mem_Iic
code: @[simp]
theorem mem_Iic : x ∈ Iic b ↔ x ≤ b 
goal: x ∈ Set.Iic b ↔ x ≤ b

full_name: Set.mem_Ioc
code: @[simp]
theorem mem_Ioc : x ∈ Ioc a b ↔ a < x ∧ x ≤ b 
goal: x ∈ Set.Ioc a b ↔ a < x ∧ x ≤ b

full_name: Set.mem_Ici
code: @[simp]
theorem mem_Ici : x ∈ Ici a ↔ a ≤ x 
goal: x ∈ Set.Ici a ↔ a ≤ x

full_name: Set.mem_Ioi
code: @[simp]
theorem mem_Ioi : x ∈ Ioi a ↔ a < x 
goal: x ∈ Set.Ioi a ↔ a < x

full_name: Set.decidableMemIoo
code: instance decidableMemIoo [Decidable (a < x ∧ x < b)] : Decidable (x ∈ Ioo a b) 
goal: Decidable (x ∈ Set.Ioo a b)

full_name: Set.decidableMemIco
code: instance decidableMemIco [Decidable (a ≤ x ∧ x < b)] : Decidable (x ∈ Ico a b) 
goal: Decidable (x ∈ Set.Ico a b)

full_name: Set.decidableMemIio
code: instance decidableMemIio [Decidable (x < b)] : Decidable (x ∈ Iio b) 
goal: Decidable (x ∈ Set.Iio b)

full_name: Set.decidableMemIcc
code: instance decidableMemIcc [Decidable (a ≤ x ∧ x ≤ b)] : Decidable (x ∈ Icc a b) 
goal: Decidable (x ∈ Set.Icc a b)

full_name: Set.decidableMemIic
code: instance decidableMemIic [Decidable (x ≤ b)] : Decidable (x ∈ Iic b) 
goal: Decidable (x ∈ Set.Iic b)

full_name: Set.decidableMemIoc
code: instance decidableMemIoc [Decidable (a < x ∧ x ≤ b)] : Decidable (x ∈ Ioc a b) 
goal: Decidable (x ∈ Set.Ioc a b)

full_name: Set.decidableMemIci
code: instance decidableMemIci [Decidable (a ≤ x)] : Decidable (x ∈ Ici a) 
goal: Decidable (x ∈ Set.Ici a)

full_name: Set.decidableMemIoi
code: instance decidableMemIoi [Decidable (a < x)] : Decidable (x ∈ Ioi a) 
goal: Decidable (x ∈ Set.Ioi a)

full_name: Set.left_mem_Ioo
code: theorem left_mem_Ioo : a ∈ Ioo a b ↔ False 
goal: a ∈ Set.Ioo a b ↔ False

full_name: Set.left_mem_Ico
code: theorem left_mem_Ico : a ∈ Ico a b ↔ a < b 
goal: a ∈ Set.Ico a b ↔ a < b

full_name: Set.left_mem_Icc
code: theorem left_mem_Icc : a ∈ Icc a b ↔ a ≤ b 
goal: a ∈ Set.Icc a b ↔ a ≤ b

full_name: Set.left_mem_Ioc
code: theorem left_mem_Ioc : a ∈ Ioc a b ↔ False 
goal: a ∈ Set.Ioc a b ↔ False

full_name: Set.left_mem_Ici
code: theorem left_mem_Ici : a ∈ Ici a 
goal: a ∈ Set.Ici a

full_name: Set.right_mem_Ioo
code: theorem right_mem_Ioo : b ∈ Ioo a b ↔ False 
goal: b ∈ Set.Ioo a b ↔ False

full_name: Set.right_mem_Ico
code: theorem right_mem_Ico : b ∈ Ico a b ↔ False 
goal: b ∈ Set.Ico a b ↔ False

full_name: Set.right_mem_Icc
code: theorem right_mem_Icc : b ∈ Icc a b ↔ a ≤ b 
goal: b ∈ Set.Icc a b ↔ a ≤ b

full_name: Set.right_mem_Ioc
code: theorem right_mem_Ioc : b ∈ Ioc a b ↔ a < b 
goal: b ∈ Set.Ioc a b ↔ a < b

full_name: Set.right_mem_Iic
code: theorem right_mem_Iic : a ∈ Iic a 
goal: a ∈ Set.Iic a

full_name: Set.dual_Ici
code: @[simp]
theorem dual_Ici : Ici (toDual a) = ofDual ⁻¹' Iic a 
goal: Set.Ici (OrderDual.toDual a) = ⇑OrderDual.ofDual ⁻¹' Set.Iic a

full_name: Set.dual_Iic
code: @[simp]
theorem dual_Iic : Iic (toDual a) = ofDual ⁻¹' Ici a 
goal: Set.Iic (OrderDual.toDual a) = ⇑OrderDual.ofDual ⁻¹' Set.Ici a

full_name: Set.dual_Ioi
code: @[simp]
theorem dual_Ioi : Ioi (toDual a) = ofDual ⁻¹' Iio a 
goal: Set.Ioi (OrderDual.toDual a) = ⇑OrderDual.ofDual ⁻¹' Set.Iio a

full_name: Set.dual_Iio
code: @[simp]
theorem dual_Iio : Iio (toDual a) = ofDual ⁻¹' Ioi a 
goal: Set.Iio (OrderDual.toDual a) = ⇑OrderDual.ofDual ⁻¹' Set.Ioi a

full_name: Set.dual_Icc
code: @[simp]
theorem dual_Icc : Icc (toDual a) (toDual b) = ofDual ⁻¹' Icc b a 
goal: Set.Icc (OrderDual.toDual a) (OrderDual.toDual b) = ⇑OrderDual.ofDual ⁻¹' Set.Icc b a

full_name: Set.dual_Ioc
code: @[simp]
theorem dual_Ioc : Ioc (toDual a) (toDual b) = ofDual ⁻¹' Ico b a 
goal: Set.Ioc (OrderDual.toDual a) (OrderDual.toDual b) = ⇑OrderDual.ofDual ⁻¹' Set.Ico b a

full_name: Set.dual_Ico
code: @[simp]
theorem dual_Ico : Ico (toDual a) (toDual b) = ofDual ⁻¹' Ioc b a 
goal: Set.Ico (OrderDual.toDual a) (OrderDual.toDual b) = ⇑OrderDual.ofDual ⁻¹' Set.Ioc b a

full_name: Set.dual_Ioo
code: @[simp]
theorem dual_Ioo : Ioo (toDual a) (toDual b) = ofDual ⁻¹' Ioo b a 
goal: Set.Ioo (OrderDual.toDual a) (OrderDual.toDual b) = ⇑OrderDual.ofDual ⁻¹' Set.Ioo b a

full_name: Set.nonempty_Icc
code: @[simp]
theorem nonempty_Icc : (Icc a b).Nonempty ↔ a ≤ b 
goal: (Set.Icc a b).Nonempty ↔ a ≤ b

full_name: Set.nonempty_Ico
code: @[simp]
theorem nonempty_Ico : (Ico a b).Nonempty ↔ a < b 
goal: (Set.Ico a b).Nonempty ↔ a < b

full_name: Set.nonempty_Ioc
code: @[simp]
theorem nonempty_Ioc : (Ioc a b).Nonempty ↔ a < b 
goal: (Set.Ioc a b).Nonempty ↔ a < b

full_name: Set.nonempty_Ici
code: @[simp]
theorem nonempty_Ici : (Ici a).Nonempty 
goal: (Set.Ici a).Nonempty

full_name: Set.nonempty_Iic
code: @[simp]
theorem nonempty_Iic : (Iic a).Nonempty 
goal: (Set.Iic a).Nonempty

full_name: Set.nonempty_Ioo
code: @[simp]
theorem nonempty_Ioo [DenselyOrdered α] : (Ioo a b).Nonempty ↔ a < b 
goal: (Set.Ioo a b).Nonempty ↔ a < b

full_name: Set.nonempty_Ioi
code: @[simp]
theorem nonempty_Ioi [NoMaxOrder α] : (Ioi a).Nonempty 
goal: (Set.Ioi a).Nonempty

full_name: Set.nonempty_Iio
code: @[simp]
theorem nonempty_Iio [NoMinOrder α] : (Iio a).Nonempty 
goal: (Set.Iio a).Nonempty

full_name: Set.nonempty_Icc_subtype
code: theorem nonempty_Icc_subtype (h : a ≤ b) : Nonempty (Icc a b) 
goal: Nonempty ↑(Set.Icc a b)

full_name: Set.nonempty_Ico_subtype
code: theorem nonempty_Ico_subtype (h : a < b) : Nonempty (Ico a b) 
goal: Nonempty ↑(Set.Ico a b)

full_name: Set.nonempty_Ioc_subtype
code: theorem nonempty_Ioc_subtype (h : a < b) : Nonempty (Ioc a b) 
goal: Nonempty ↑(Set.Ioc a b)

full_name: Set.nonempty_Ici_subtype
code: /-- An interval `Ici a` is nonempty. -/
instance nonempty_Ici_subtype : Nonempty (Ici a) 
goal: Nonempty ↑(Set.Ici a)

full_name: Set.nonempty_Iic_subtype
code: /-- An interval `Iic a` is nonempty. -/
instance nonempty_Iic_subtype : Nonempty (Iic a) 
goal: Nonempty ↑(Set.Iic a)

full_name: Set.nonempty_Ioo_subtype
code: theorem nonempty_Ioo_subtype [DenselyOrdered α] (h : a < b) : Nonempty (Ioo a b) 
goal: Nonempty ↑(Set.Ioo a b)

full_name: Set.nonempty_Ioi_subtype
code: /-- In an order without maximal elements, the intervals `Ioi` are nonempty. -/
instance nonempty_Ioi_subtype [NoMaxOrder α] : Nonempty (Ioi a) 
goal: Nonempty ↑(Set.Ioi a)

full_name: Set.nonempty_Iio_subtype
code: /-- In an order without minimal elements, the intervals `Iio` are nonempty. -/
instance nonempty_Iio_subtype [NoMinOrder α] : Nonempty (Iio a) 
goal: Nonempty ↑(Set.Iio a)

full_name: Set.instNoMinOrderElemIio
code: instance [NoMinOrder α] : NoMinOrder (Iio a) 
goal: NoMinOrder ↑(Set.Iio a)

full_name: Set.instNoMinOrderElemIic
code: instance [NoMinOrder α] : NoMinOrder (Iic a) 
goal: NoMinOrder ↑(Set.Iic a)

full_name: Set.instNoMaxOrderElemIoi
code: instance [NoMaxOrder α] : NoMaxOrder (Ioi a) 
goal: NoMaxOrder ↑(Set.Ioi a)

full_name: Set.instNoMaxOrderElemIci
code: instance [NoMaxOrder α] : NoMaxOrder (Ici a) 
goal: NoMaxOrder ↑(Set.Ici a)

full_name: Set.Icc_eq_empty
code: @[simp]
theorem Icc_eq_empty (h : ¬a ≤ b) : Icc a b = ∅ 
goal: Set.Icc a b = ∅

full_name: Set.Ico_eq_empty
code: @[simp]
theorem Ico_eq_empty (h : ¬a < b) : Ico a b = ∅ 
goal: Set.Ico a b = ∅

full_name: Set.Ioc_eq_empty
code: @[simp]
theorem Ioc_eq_empty (h : ¬a < b) : Ioc a b = ∅ 
goal: Set.Ioc a b = ∅

full_name: Set.Ioo_eq_empty
code: @[simp]
theorem Ioo_eq_empty (h : ¬a < b) : Ioo a b = ∅ 
goal: Set.Ioo a b = ∅

full_name: Set.Icc_eq_empty_of_lt
code: @[simp]
theorem Icc_eq_empty_of_lt (h : b < a) : Icc a b = ∅ 
goal: Set.Icc a b = ∅

full_name: Set.Ico_eq_empty_of_le
code: @[simp]
theorem Ico_eq_empty_of_le (h : b ≤ a) : Ico a b = ∅ 
goal: Set.Ico a b = ∅

full_name: Set.Ioc_eq_empty_of_le
code: @[simp]
theorem Ioc_eq_empty_of_le (h : b ≤ a) : Ioc a b = ∅ 
goal: Set.Ioc a b = ∅

full_name: Set.Ioo_eq_empty_of_le
code: @[simp]
theorem Ioo_eq_empty_of_le (h : b ≤ a) : Ioo a b = ∅ 
goal: Set.Ioo a b = ∅

full_name: Set.Ico_self
code: theorem Ico_self (a : α) : Ico a a = ∅ 
goal: Set.Ico a a = ∅

full_name: Set.Ioc_self
code: theorem Ioc_self (a : α) : Ioc a a = ∅ 
goal: Set.Ioc a a = ∅

full_name: Set.Ioo_self
code: theorem Ioo_self (a : α) : Ioo a a = ∅ 
goal: Set.Ioo a a = ∅

full_name: Set.Ici_subset_Ici
code: theorem Ici_subset_Ici : Ici a ⊆ Ici b ↔ b ≤ a 
goal: Set.Ici a ⊆ Set.Ici b ↔ b ≤ a

full_name: Set.Iic_subset_Iic
code: theorem Iic_subset_Iic : Iic a ⊆ Iic b ↔ a ≤ b 
goal: Set.Iic a ⊆ Set.Iic b ↔ a ≤ b

full_name: Set.Ici_subset_Ioi
code: theorem Ici_subset_Ioi : Ici a ⊆ Ioi b ↔ b < a 
goal: Set.Ici a ⊆ Set.Ioi b ↔ b < a

full_name: Set.Iic_subset_Iio
code: theorem Iic_subset_Iio : Iic a ⊆ Iio b ↔ a < b 
goal: Set.Iic a ⊆ Set.Iio b ↔ a < b

full_name: Set.Ioo_subset_Ioo
code: @[gcongr]
theorem Ioo_subset_Ioo (h₁ : a₂ ≤ a₁) (h₂ : b₁ ≤ b₂) : Ioo a₁ b₁ ⊆ Ioo a₂ b₂ 
goal: Set.Ioo a₁ b₁ ⊆ Set.Ioo a₂ b₂

full_name: Set.Ioo_subset_Ioo_left
code: @[gcongr]
theorem Ioo_subset_Ioo_left (h : a₁ ≤ a₂) : Ioo a₂ b ⊆ Ioo a₁ b 
goal: Set.Ioo a₂ b ⊆ Set.Ioo a₁ b

full_name: Set.Ioo_subset_Ioo_right
code: @[gcongr]
theorem Ioo_subset_Ioo_right (h : b₁ ≤ b₂) : Ioo a b₁ ⊆ Ioo a b₂ 
goal: Set.Ioo a b₁ ⊆ Set.Ioo a b₂

full_name: Set.Ico_subset_Ico
code: @[gcongr]
theorem Ico_subset_Ico (h₁ : a₂ ≤ a₁) (h₂ : b₁ ≤ b₂) : Ico a₁ b₁ ⊆ Ico a₂ b₂ 
goal: Set.Ico a₁ b₁ ⊆ Set.Ico a₂ b₂

full_name: Set.Ico_subset_Ico_left
code: @[gcongr]
theorem Ico_subset_Ico_left (h : a₁ ≤ a₂) : Ico a₂ b ⊆ Ico a₁ b 
goal: Set.Ico a₂ b ⊆ Set.Ico a₁ b

full_name: Set.Ico_subset_Ico_right
code: @[gcongr]
theorem Ico_subset_Ico_right (h : b₁ ≤ b₂) : Ico a b₁ ⊆ Ico a b₂ 
goal: Set.Ico a b₁ ⊆ Set.Ico a b₂

full_name: Set.Icc_subset_Icc
code: @[gcongr]
theorem Icc_subset_Icc (h₁ : a₂ ≤ a₁) (h₂ : b₁ ≤ b₂) : Icc a₁ b₁ ⊆ Icc a₂ b₂ 
goal: Set.Icc a₁ b₁ ⊆ Set.Icc a₂ b₂

full_name: Set.Icc_subset_Icc_left
code: @[gcongr]
theorem Icc_subset_Icc_left (h : a₁ ≤ a₂) : Icc a₂ b ⊆ Icc a₁ b 
goal: Set.Icc a₂ b ⊆ Set.Icc a₁ b

full_name: Set.Icc_subset_Icc_right
code: @[gcongr]
theorem Icc_subset_Icc_right (h : b₁ ≤ b₂) : Icc a b₁ ⊆ Icc a b₂ 
goal: Set.Icc a b₁ ⊆ Set.Icc a b₂

full_name: Set.Icc_subset_Ioo
code: theorem Icc_subset_Ioo (ha : a₂ < a₁) (hb : b₁ < b₂) : Icc a₁ b₁ ⊆ Ioo a₂ b₂ 
goal: Set.Icc a₁ b₁ ⊆ Set.Ioo a₂ b₂

full_name: Set.Icc_subset_Ici_self
code: theorem Icc_subset_Ici_self : Icc a b ⊆ Ici a 
goal: Set.Icc a b ⊆ Set.Ici a

full_name: Set.Icc_subset_Iic_self
code: theorem Icc_subset_Iic_self : Icc a b ⊆ Iic b 
goal: Set.Icc a b ⊆ Set.Iic b

full_name: Set.Ioc_subset_Iic_self
code: theorem Ioc_subset_Iic_self : Ioc a b ⊆ Iic b 
goal: Set.Ioc a b ⊆ Set.Iic b

full_name: Set.Ioc_subset_Ioc
code: @[gcongr]
theorem Ioc_subset_Ioc (h₁ : a₂ ≤ a₁) (h₂ : b₁ ≤ b₂) : Ioc a₁ b₁ ⊆ Ioc a₂ b₂ 
goal: Set.Ioc a₁ b₁ ⊆ Set.Ioc a₂ b₂

full_name: Set.Ioc_subset_Ioc_left
code: @[gcongr]
theorem Ioc_subset_Ioc_left (h : a₁ ≤ a₂) : Ioc a₂ b ⊆ Ioc a₁ b 
goal: Set.Ioc a₂ b ⊆ Set.Ioc a₁ b

full_name: Set.Ioc_subset_Ioc_right
code: @[gcongr]
theorem Ioc_subset_Ioc_right (h : b₁ ≤ b₂) : Ioc a b₁ ⊆ Ioc a b₂ 
goal: Set.Ioc a b₁ ⊆ Set.Ioc a b₂

full_name: Set.Ico_subset_Ioo_left
code: theorem Ico_subset_Ioo_left (h₁ : a₁ < a₂) : Ico a₂ b ⊆ Ioo a₁ b 
goal: Set.Ico a₂ b ⊆ Set.Ioo a₁ b

full_name: Set.Ioc_subset_Ioo_right
code: theorem Ioc_subset_Ioo_right (h : b₁ < b₂) : Ioc a b₁ ⊆ Ioo a b₂ 
goal: Set.Ioc a b₁ ⊆ Set.Ioo a b₂

full_name: Set.Icc_subset_Ico_right
code: theorem Icc_subset_Ico_right (h₁ : b₁ < b₂) : Icc a b₁ ⊆ Ico a b₂ 
goal: Set.Icc a b₁ ⊆ Set.Ico a b₂

full_name: Set.Ioo_subset_Ico_self
code: theorem Ioo_subset_Ico_self : Ioo a b ⊆ Ico a b 
goal: Set.Ioo a b ⊆ Set.Ico a b

full_name: Set.Ioo_subset_Ioc_self
code: theorem Ioo_subset_Ioc_self : Ioo a b ⊆ Ioc a b 
goal: Set.Ioo a b ⊆ Set.Ioc a b

full_name: Set.Ico_subset_Icc_self
code: theorem Ico_subset_Icc_self : Ico a b ⊆ Icc a b 
goal: Set.Ico a b ⊆ Set.Icc a b

full_name: Set.Ioc_subset_Icc_self
code: theorem Ioc_subset_Icc_self : Ioc a b ⊆ Icc a b 
goal: Set.Ioc a b ⊆ Set.Icc a b

full_name: Set.Ioo_subset_Icc_self
code: theorem Ioo_subset_Icc_self : Ioo a b ⊆ Icc a b 
goal: Set.Ioo a b ⊆ Set.Icc a b

full_name: Set.Ico_subset_Iio_self
code: theorem Ico_subset_Iio_self : Ico a b ⊆ Iio b 
goal: Set.Ico a b ⊆ Set.Iio b

full_name: Set.Ioo_subset_Iio_self
code: theorem Ioo_subset_Iio_self : Ioo a b ⊆ Iio b 
goal: Set.Ioo a b ⊆ Set.Iio b

full_name: Set.Ioc_subset_Ioi_self
code: theorem Ioc_subset_Ioi_self : Ioc a b ⊆ Ioi a 
goal: Set.Ioc a b ⊆ Set.Ioi a

full_name: Set.Ioo_subset_Ioi_self
code: theorem Ioo_subset_Ioi_self : Ioo a b ⊆ Ioi a 
goal: Set.Ioo a b ⊆ Set.Ioi a

full_name: Set.Ioi_subset_Ici_self
code: theorem Ioi_subset_Ici_self : Ioi a ⊆ Ici a 
goal: Set.Ioi a ⊆ Set.Ici a

full_name: Set.Iio_subset_Iic_self
code: theorem Iio_subset_Iic_self : Iio a ⊆ Iic a 
goal: Set.Iio a ⊆ Set.Iic a

full_name: Set.Ico_subset_Ici_self
code: theorem Ico_subset_Ici_self : Ico a b ⊆ Ici a 
goal: Set.Ico a b ⊆ Set.Ici a

full_name: Set.Ioi_ssubset_Ici_self
code: theorem Ioi_ssubset_Ici_self : Ioi a ⊂ Ici a 
goal: Set.Ioi a ⊂ Set.Ici a

full_name: Set.Iio_ssubset_Iic_self
code: theorem Iio_ssubset_Iic_self : Iio a ⊂ Iic a 
goal: Set.Iio a ⊂ Set.Iic a

full_name: Set.Icc_subset_Icc_iff
code: theorem Icc_subset_Icc_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Icc a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂ 
goal: Set.Icc a₁ b₁ ⊆ Set.Icc a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂

full_name: Set.Icc_subset_Ioo_iff
code: theorem Icc_subset_Ioo_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Ioo a₂ b₂ ↔ a₂ < a₁ ∧ b₁ < b₂ 
goal: Set.Icc a₁ b₁ ⊆ Set.Ioo a₂ b₂ ↔ a₂ < a₁ ∧ b₁ < b₂

full_name: Set.Icc_subset_Ico_iff
code: theorem Icc_subset_Ico_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Ico a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ < b₂ 
goal: Set.Icc a₁ b₁ ⊆ Set.Ico a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ < b₂

full_name: Set.Icc_subset_Ioc_iff
code: theorem Icc_subset_Ioc_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Ioc a₂ b₂ ↔ a₂ < a₁ ∧ b₁ ≤ b₂ 
goal: Set.Icc a₁ b₁ ⊆ Set.Ioc a₂ b₂ ↔ a₂ < a₁ ∧ b₁ ≤ b₂

full_name: Set.Icc_subset_Iio_iff
code: theorem Icc_subset_Iio_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Iio b₂ ↔ b₁ < b₂ 
goal: Set.Icc a₁ b₁ ⊆ Set.Iio b₂ ↔ b₁ < b₂

full_name: Set.Icc_subset_Ioi_iff
code: theorem Icc_subset_Ioi_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Ioi a₂ ↔ a₂ < a₁ 
goal: Set.Icc a₁ b₁ ⊆ Set.Ioi a₂ ↔ a₂ < a₁

full_name: Set.Icc_subset_Iic_iff
code: theorem Icc_subset_Iic_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Iic b₂ ↔ b₁ ≤ b₂ 
goal: Set.Icc a₁ b₁ ⊆ Set.Iic b₂ ↔ b₁ ≤ b₂

full_name: Set.Icc_subset_Ici_iff
code: theorem Icc_subset_Ici_iff (h₁ : a₁ ≤ b₁) : Icc a₁ b₁ ⊆ Ici a₂ ↔ a₂ ≤ a₁ 
goal: Set.Icc a₁ b₁ ⊆ Set.Ici a₂ ↔ a₂ ≤ a₁

full_name: Set.Icc_ssubset_Icc_left
code: theorem Icc_ssubset_Icc_left (hI : a₂ ≤ b₂) (ha : a₂ < a₁) (hb : b₁ ≤ b₂) : Icc a₁ b₁ ⊂ Icc a₂ b₂ 
goal: Set.Icc a₁ b₁ ⊂ Set.Icc a₂ b₂

full_name: Set.Icc_ssubset_Icc_right
code: theorem Icc_ssubset_Icc_right (hI : a₂ ≤ b₂) (ha : a₂ ≤ a₁) (hb : b₁ < b₂) :
    Icc a₁ b₁ ⊂ Icc a₂ b₂ 
goal: Set.Icc a₁ b₁ ⊂ Set.Icc a₂ b₂

full_name: Set.Ioi_subset_Ioi
code: /-- If `a ≤ b`, then `(b, +∞) ⊆ (a, +∞)`. In preorders, this is just an implication. If you need
the equivalence in linear orders, use `Ioi_subset_Ioi_iff`. -/
@[gcongr]
theorem Ioi_subset_Ioi (h : a ≤ b) : Ioi b ⊆ Ioi a 
goal: Set.Ioi b ⊆ Set.Ioi a

full_name: Set.Ioi_subset_Ici
code: /-- If `a ≤ b`, then `(b, +∞) ⊆ [a, +∞)`. In preorders, this is just an implication. If you need
the equivalence in dense linear orders, use `Ioi_subset_Ici_iff`. -/
theorem Ioi_subset_Ici (h : a ≤ b) : Ioi b ⊆ Ici a 
goal: Set.Ioi b ⊆ Set.Ici a

full_name: Set.Iio_subset_Iio
code: /-- If `a ≤ b`, then `(-∞, a) ⊆ (-∞, b)`. In preorders, this is just an implication. If you need
the equivalence in linear orders, use `Iio_subset_Iio_iff`. -/
@[gcongr]
theorem Iio_subset_Iio (h : a ≤ b) : Iio a ⊆ Iio b 
goal: Set.Iio a ⊆ Set.Iio b

full_name: Set.Iio_subset_Iic
code: /-- If `a ≤ b`, then `(-∞, a) ⊆ (-∞, b]`. In preorders, this is just an implication. If you need
the equivalence in dense linear orders, use `Iio_subset_Iic_iff`. -/
theorem Iio_subset_Iic (h : a ≤ b) : Iio a ⊆ Iic b 
goal: Set.Iio a ⊆ Set.Iic b

full_name: Set.Ici_inter_Iic
code: theorem Ici_inter_Iic : Ici a ∩ Iic b = Icc a b 
goal: Set.Ici a ∩ Set.Iic b = Set.Icc a b

full_name: Set.Ici_inter_Iio
code: theorem Ici_inter_Iio : Ici a ∩ Iio b = Ico a b 
goal: Set.Ici a ∩ Set.Iio b = Set.Ico a b

full_name: Set.Ioi_inter_Iic
code: theorem Ioi_inter_Iic : Ioi a ∩ Iic b = Ioc a b 
goal: Set.Ioi a ∩ Set.Iic b = Set.Ioc a b

full_name: Set.Ioi_inter_Iio
code: theorem Ioi_inter_Iio : Ioi a ∩ Iio b = Ioo a b 
goal: Set.Ioi a ∩ Set.Iio b = Set.Ioo a b

full_name: Set.Iic_inter_Ici
code: theorem Iic_inter_Ici : Iic a ∩ Ici b = Icc b a 
goal: Set.Iic a ∩ Set.Ici b = Set.Icc b a

full_name: Set.Iio_inter_Ici
code: theorem Iio_inter_Ici : Iio a ∩ Ici b = Ico b a 
goal: Set.Iio a ∩ Set.Ici b = Set.Ico b a

full_name: Set.Iic_inter_Ioi
code: theorem Iic_inter_Ioi : Iic a ∩ Ioi b = Ioc b a 
goal: Set.Iic a ∩ Set.Ioi b = Set.Ioc b a

full_name: Set.Iio_inter_Ioi
code: theorem Iio_inter_Ioi : Iio a ∩ Ioi b = Ioo b a 
goal: Set.Iio a ∩ Set.Ioi b = Set.Ioo b a

full_name: Set.mem_Icc_of_Ioo
code: theorem mem_Icc_of_Ioo (h : x ∈ Ioo a b) : x ∈ Icc a b 
goal: x ∈ Set.Icc a b

full_name: Set.mem_Ico_of_Ioo
code: theorem mem_Ico_of_Ioo (h : x ∈ Ioo a b) : x ∈ Ico a b 
goal: x ∈ Set.Ico a b

full_name: Set.mem_Ioc_of_Ioo
code: theorem mem_Ioc_of_Ioo (h : x ∈ Ioo a b) : x ∈ Ioc a b 
goal: x ∈ Set.Ioc a b

full_name: Set.mem_Icc_of_Ico
code: theorem mem_Icc_of_Ico (h : x ∈ Ico a b) : x ∈ Icc a b 
goal: x ∈ Set.Icc a b

full_name: Set.mem_Icc_of_Ioc
code: theorem mem_Icc_of_Ioc (h : x ∈ Ioc a b) : x ∈ Icc a b 
goal: x ∈ Set.Icc a b

full_name: Set.mem_Ici_of_Ioi
code: theorem mem_Ici_of_Ioi (h : x ∈ Ioi a) : x ∈ Ici a 
goal: x ∈ Set.Ici a

full_name: Set.mem_Iic_of_Iio
code: theorem mem_Iic_of_Iio (h : x ∈ Iio a) : x ∈ Iic a 
goal: x ∈ Set.Iic a

full_name: Set.Icc_eq_empty_iff
code: theorem Icc_eq_empty_iff : Icc a b = ∅ ↔ ¬a ≤ b 
goal: Set.Icc a b = ∅ ↔ ¬a ≤ b

full_name: Set.Ico_eq_empty_iff
code: theorem Ico_eq_empty_iff : Ico a b = ∅ ↔ ¬a < b 
goal: Set.Ico a b = ∅ ↔ ¬a < b

full_name: Set.Ioc_eq_empty_iff
code: theorem Ioc_eq_empty_iff : Ioc a b = ∅ ↔ ¬a < b 
goal: Set.Ioc a b = ∅ ↔ ¬a < b

full_name: Set.Ioo_eq_empty_iff
code: theorem Ioo_eq_empty_iff [DenselyOrdered α] : Ioo a b = ∅ ↔ ¬a < b 
goal: Set.Ioo a b = ∅ ↔ ¬a < b

full_name: IsTop.Iic_eq
code: theorem _root_.IsTop.Iic_eq (h : IsTop a) : Iic a = univ 
goal: Set.Iic a = Set.univ

full_name: IsBot.Ici_eq
code: theorem _root_.IsBot.Ici_eq (h : IsBot a) : Ici a = univ 
goal: Set.Ici a = Set.univ

full_name: IsMax.Ioi_eq
code: theorem _root_.IsMax.Ioi_eq (h : IsMax a) : Ioi a = ∅ 
goal: Set.Ioi a = ∅

full_name: IsMin.Iio_eq
code: theorem _root_.IsMin.Iio_eq (h : IsMin a) : Iio a = ∅ 
goal: Set.Iio a = ∅

full_name: Set.Iic_inter_Ioc_of_le
code: theorem Iic_inter_Ioc_of_le (h : a ≤ c) : Iic a ∩ Ioc b c = Ioc b a 
goal: Set.Iic a ∩ Set.Ioc b c = Set.Ioc b a

full_name: Set.not_mem_Icc_of_lt
code: theorem not_mem_Icc_of_lt (ha : c < a) : c ∉ Icc a b 
goal: c ∉ Set.Icc a b

full_name: Set.not_mem_Icc_of_gt
code: theorem not_mem_Icc_of_gt (hb : b < c) : c ∉ Icc a b 
goal: c ∉ Set.Icc a b

full_name: Set.not_mem_Ico_of_lt
code: theorem not_mem_Ico_of_lt (ha : c < a) : c ∉ Ico a b 
goal: c ∉ Set.Ico a b

full_name: Set.not_mem_Ioc_of_gt
code: theorem not_mem_Ioc_of_gt (hb : b < c) : c ∉ Ioc a b 
goal: c ∉ Set.Ioc a b

full_name: Set.not_mem_Ioi_self
code: theorem not_mem_Ioi_self : a ∉ Ioi a 
goal: a ∉ Set.Ioi a

full_name: Set.not_mem_Iio_self
code: theorem not_mem_Iio_self : b ∉ Iio b 
goal: b ∉ Set.Iio b

full_name: Set.not_mem_Ioc_of_le
code: theorem not_mem_Ioc_of_le (ha : c ≤ a) : c ∉ Ioc a b 
goal: c ∉ Set.Ioc a b

full_name: Set.not_mem_Ico_of_ge
code: theorem not_mem_Ico_of_ge (hb : b ≤ c) : c ∉ Ico a b 
goal: c ∉ Set.Ico a b

full_name: Set.not_mem_Ioo_of_le
code: theorem not_mem_Ioo_of_le (ha : c ≤ a) : c ∉ Ioo a b 
goal: c ∉ Set.Ioo a b

full_name: Set.not_mem_Ioo_of_ge
code: theorem not_mem_Ioo_of_ge (hb : b ≤ c) : c ∉ Ioo a b 
goal: c ∉ Set.Ioo a b

full_name: Set.Icc_self
code: @[simp]
theorem Icc_self (a : α) : Icc a a = {a} 
goal: Set.Icc a a = {a}

full_name: Set.instIccUnique
code: instance instIccUnique : Unique (Set.Icc a a) 
goal: Unique ↑(Set.Icc a a)

full_name: Set.Icc_eq_singleton_iff
code: @[simp]
theorem Icc_eq_singleton_iff : Icc a b = {c} ↔ a = c ∧ b = c 
goal: Set.Icc a b = {c} ↔ a = c ∧ b = c

full_name: Set.subsingleton_Icc_of_ge
code: lemma subsingleton_Icc_of_ge (hba : b ≤ a) : Set.Subsingleton (Icc a b) 
goal: (Set.Icc a b).Subsingleton

full_name: Set.subsingleton_Icc_iff
code: @[simp] lemma subsingleton_Icc_iff {α : Type*} [LinearOrder α] {a b : α} :
    Set.Subsingleton (Icc a b) ↔ b ≤ a 
goal: (Set.Icc a b).Subsingleton ↔ b ≤ a

full_name: Set.Icc_diff_left
code: @[simp]
theorem Icc_diff_left : Icc a b \ {a} = Ioc a b 
goal: Set.Icc a b \ {a} = Set.Ioc a b

full_name: Set.Icc_diff_right
code: @[simp]
theorem Icc_diff_right : Icc a b \ {b} = Ico a b 
goal: Set.Icc a b \ {b} = Set.Ico a b

full_name: Set.Ico_diff_left
code: @[simp]
theorem Ico_diff_left : Ico a b \ {a} = Ioo a b 
goal: Set.Ico a b \ {a} = Set.Ioo a b

full_name: Set.Ioc_diff_right
code: @[simp]
theorem Ioc_diff_right : Ioc a b \ {b} = Ioo a b 
goal: Set.Ioc a b \ {b} = Set.Ioo a b

full_name: Set.Icc_diff_both
code: @[simp]
theorem Icc_diff_both : Icc a b \ {a, b} = Ioo a b 
goal: Set.Icc a b \ {a, b} = Set.Ioo a b

full_name: Set.Ici_diff_left
code: @[simp]
theorem Ici_diff_left : Ici a \ {a} = Ioi a 
goal: Set.Ici a \ {a} = Set.Ioi a

full_name: Set.Iic_diff_right
code: @[simp]
theorem Iic_diff_right : Iic a \ {a} = Iio a 
goal: Set.Iic a \ {a} = Set.Iio a

full_name: Set.Ico_diff_Ioo_same
code: @[simp]
theorem Ico_diff_Ioo_same (h : a < b) : Ico a b \ Ioo a b = {a} 
goal: Set.Ico a b \ Set.Ioo a b = {a}

full_name: Set.Ioc_diff_Ioo_same
code: @[simp]
theorem Ioc_diff_Ioo_same (h : a < b) : Ioc a b \ Ioo a b = {b} 
goal: Set.Ioc a b \ Set.Ioo a b = {b}

full_name: Set.Icc_diff_Ico_same
code: @[simp]
theorem Icc_diff_Ico_same (h : a ≤ b) : Icc a b \ Ico a b = {b} 
goal: Set.Icc a b \ Set.Ico a b = {b}

full_name: Set.Icc_diff_Ioc_same
code: @[simp]
theorem Icc_diff_Ioc_same (h : a ≤ b) : Icc a b \ Ioc a b = {a} 
goal: Set.Icc a b \ Set.Ioc a b = {a}

full_name: Set.Icc_diff_Ioo_same
code: @[simp]
theorem Icc_diff_Ioo_same (h : a ≤ b) : Icc a b \ Ioo a b = {a, b} 
goal: Set.Icc a b \ Set.Ioo a b = {a, b}

full_name: Set.Ici_diff_Ioi_same
code: @[simp]
theorem Ici_diff_Ioi_same : Ici a \ Ioi a = {a} 
goal: Set.Ici a \ Set.Ioi a = {a}

full_name: Set.Iic_diff_Iio_same
code: @[simp]
theorem Iic_diff_Iio_same : Iic a \ Iio a = {a} 
goal: Set.Iic a \ Set.Iio a = {a}

full_name: Set.Ioi_union_left
code: theorem Ioi_union_left : Ioi a ∪ {a} = Ici a 
goal: Set.Ioi a ∪ {a} = Set.Ici a

full_name: Set.Iio_union_right
code: theorem Iio_union_right : Iio a ∪ {a} = Iic a 
goal: Set.Iio a ∪ {a} = Set.Iic a

full_name: Set.Ioo_union_left
code: theorem Ioo_union_left (hab : a < b) : Ioo a b ∪ {a} = Ico a b 
goal: Set.Ioo a b ∪ {a} = Set.Ico a b

full_name: Set.Ioo_union_right
code: theorem Ioo_union_right (hab : a < b) : Ioo a b ∪ {b} = Ioc a b 
goal: Set.Ioo a b ∪ {b} = Set.Ioc a b

full_name: Set.Ioo_union_both
code: theorem Ioo_union_both (h : a ≤ b) : Ioo a b ∪ {a, b} = Icc a b 
goal: Set.Ioo a b ∪ {a, b} = Set.Icc a b

full_name: Set.Ioc_union_left
code: theorem Ioc_union_left (hab : a ≤ b) : Ioc a b ∪ {a} = Icc a b 
goal: Set.Ioc a b ∪ {a} = Set.Icc a b

full_name: Set.Ico_union_right
code: theorem Ico_union_right (hab : a ≤ b) : Ico a b ∪ {b} = Icc a b 
goal: Set.Ico a b ∪ {b} = Set.Icc a b

full_name: Set.Ico_insert_right
code: @[simp]
theorem Ico_insert_right (h : a ≤ b) : insert b (Ico a b) = Icc a b 
goal: insert b (Set.Ico a b) = Set.Icc a b

full_name: Set.Ioc_insert_left
code: @[simp]
theorem Ioc_insert_left (h : a ≤ b) : insert a (Ioc a b) = Icc a b 
goal: insert a (Set.Ioc a b) = Set.Icc a b

full_name: Set.Ioo_insert_left
code: @[simp]
theorem Ioo_insert_left (h : a < b) : insert a (Ioo a b) = Ico a b 
goal: insert a (Set.Ioo a b) = Set.Ico a b

full_name: Set.Ioo_insert_right
code: @[simp]
theorem Ioo_insert_right (h : a < b) : insert b (Ioo a b) = Ioc a b 
goal: insert b (Set.Ioo a b) = Set.Ioc a b

full_name: Set.Iio_insert
code: @[simp]
theorem Iio_insert : insert a (Iio a) = Iic a 
goal: insert a (Set.Iio a) = Set.Iic a

full_name: Set.Ioi_insert
code: @[simp]
theorem Ioi_insert : insert a (Ioi a) = Ici a 
goal: insert a (Set.Ioi a) = Set.Ici a

full_name: Set.mem_Ici_Ioi_of_subset_of_subset
code: theorem mem_Ici_Ioi_of_subset_of_subset {s : Set α} (ho : Ioi a ⊆ s) (hc : s ⊆ Ici a) :
    s ∈ ({Ici a, Ioi a} : Set (Set α)) 
goal: s ∈ {Set.Ici a, Set.Ioi a}

full_name: Set.mem_Iic_Iio_of_subset_of_subset
code: theorem mem_Iic_Iio_of_subset_of_subset {s : Set α} (ho : Iio a ⊆ s) (hc : s ⊆ Iic a) :
    s ∈ ({Iic a, Iio a} : Set (Set α)) 
goal: s ∈ {Set.Iic a, Set.Iio a}

full_name: Set.mem_Icc_Ico_Ioc_Ioo_of_subset_of_subset
code: theorem mem_Icc_Ico_Ioc_Ioo_of_subset_of_subset {s : Set α} (ho : Ioo a b ⊆ s) (hc : s ⊆ Icc a b) :
    s ∈ ({Icc a b, Ico a b, Ioc a b, Ioo a b} : Set (Set α)) 
goal: s ∈ {Set.Icc a b, Set.Ico a b, Set.Ioc a b, Set.Ioo a b}

full_name: Set.eq_left_or_mem_Ioo_of_mem_Ico
code: theorem eq_left_or_mem_Ioo_of_mem_Ico {x : α} (hmem : x ∈ Ico a b) : x = a ∨ x ∈ Ioo a b 
goal: x = a ∨ x ∈ Set.Ioo a b

full_name: Set.eq_right_or_mem_Ioo_of_mem_Ioc
code: theorem eq_right_or_mem_Ioo_of_mem_Ioc {x : α} (hmem : x ∈ Ioc a b) : x = b ∨ x ∈ Ioo a b 
goal: x = b ∨ x ∈ Set.Ioo a b

full_name: Set.eq_endpoints_or_mem_Ioo_of_mem_Icc
code: theorem eq_endpoints_or_mem_Ioo_of_mem_Icc {x : α} (hmem : x ∈ Icc a b) :
    x = a ∨ x = b ∨ x ∈ Ioo a b 
goal: x = a ∨ x = b ∨ x ∈ Set.Ioo a b

full_name: IsMax.Ici_eq
code: theorem _root_.IsMax.Ici_eq (h : IsMax a) : Ici a = {a} 
goal: Set.Ici a = {a}

full_name: IsMin.Iic_eq
code: theorem _root_.IsMin.Iic_eq (h : IsMin a) : Iic a = {a} 
goal: Set.Iic a = {a}

full_name: Set.Ici_injective
code: theorem Ici_injective : Injective (Ici : α → Set α) 
goal: Function.Injective Set.Ici

full_name: Set.Iic_injective
code: theorem Iic_injective : Injective (Iic : α → Set α) 
goal: Function.Injective Set.Iic

full_name: Set.Ici_inj
code: theorem Ici_inj : Ici a = Ici b ↔ a = b 
goal: Set.Ici a = Set.Ici b ↔ a = b

full_name: Set.Iic_inj
code: theorem Iic_inj : Iic a = Iic b ↔ a = b 
goal: Set.Iic a = Set.Iic b ↔ a = b

full_name: Set.Ici_top
code: @[simp]
theorem Ici_top [PartialOrder α] [OrderTop α] : Ici (⊤ : α) = {⊤} 
goal: Set.Ici ⊤ = {⊤}

full_name: Set.Ioi_top
code: @[simp]
theorem Ioi_top : Ioi (⊤ : α) = ∅ 
goal: Set.Ioi ⊤ = ∅

full_name: Set.Iic_top
code: @[simp]
theorem Iic_top : Iic (⊤ : α) = univ 
goal: Set.Iic ⊤ = Set.univ

full_name: Set.Icc_top
code: @[simp]
theorem Icc_top : Icc a ⊤ = Ici a 
goal: Set.Icc a ⊤ = Set.Ici a

full_name: Set.Ioc_top
code: @[simp]
theorem Ioc_top : Ioc a ⊤ = Ioi a 
goal: Set.Ioc a ⊤ = Set.Ioi a

full_name: Set.Iic_bot
code: @[simp]
theorem Iic_bot [PartialOrder α] [OrderBot α] : Iic (⊥ : α) = {⊥} 
goal: Set.Iic ⊥ = {⊥}

full_name: Set.Iio_bot
code: @[simp]
theorem Iio_bot : Iio (⊥ : α) = ∅ 
goal: Set.Iio ⊥ = ∅

full_name: Set.Ici_bot
code: @[simp]
theorem Ici_bot : Ici (⊥ : α) = univ 
goal: Set.Ici ⊥ = Set.univ

full_name: Set.Icc_bot
code: @[simp]
theorem Icc_bot : Icc ⊥ a = Iic a 
goal: Set.Icc ⊥ a = Set.Iic a

full_name: Set.Ico_bot
code: @[simp]
theorem Ico_bot : Ico ⊥ a = Iio a 
goal: Set.Ico ⊥ a = Set.Iio a

full_name: Set.Icc_bot_top
code: theorem Icc_bot_top [PartialOrder α] [BoundedOrder α] : Icc (⊥ : α) ⊤ = univ 
goal: Set.Icc ⊥ ⊤ = Set.univ

full_name: Set.not_mem_Ici
code: theorem not_mem_Ici : c ∉ Ici a ↔ c < a 
goal: c ∉ Set.Ici a ↔ c < a

full_name: Set.not_mem_Iic
code: theorem not_mem_Iic : c ∉ Iic b ↔ b < c 
goal: c ∉ Set.Iic b ↔ b < c

full_name: Set.not_mem_Ioi
code: theorem not_mem_Ioi : c ∉ Ioi a ↔ c ≤ a 
goal: c ∉ Set.Ioi a ↔ c ≤ a

full_name: Set.not_mem_Iio
code: theorem not_mem_Iio : c ∉ Iio b ↔ b ≤ c 
goal: c ∉ Set.Iio b ↔ b ≤ c

full_name: Set.compl_Iic
code: @[simp]
theorem compl_Iic : (Iic a)ᶜ = Ioi a 
goal: (Set.Iic a)ᶜ = Set.Ioi a

full_name: Set.compl_Ici
code: @[simp]
theorem compl_Ici : (Ici a)ᶜ = Iio a 
goal: (Set.Ici a)ᶜ = Set.Iio a

full_name: Set.compl_Iio
code: @[simp]
theorem compl_Iio : (Iio a)ᶜ = Ici a 
goal: (Set.Iio a)ᶜ = Set.Ici a

full_name: Set.compl_Ioi
code: @[simp]
theorem compl_Ioi : (Ioi a)ᶜ = Iic a 
goal: (Set.Ioi a)ᶜ = Set.Iic a

full_name: Set.Ici_diff_Ici
code: @[simp]
theorem Ici_diff_Ici : Ici a \ Ici b = Ico a b 
goal: Set.Ici a \ Set.Ici b = Set.Ico a b

full_name: Set.Ici_diff_Ioi
code: @[simp]
theorem Ici_diff_Ioi : Ici a \ Ioi b = Icc a b 
goal: Set.Ici a \ Set.Ioi b = Set.Icc a b

full_name: Set.Ioi_diff_Ioi
code: @[simp]
theorem Ioi_diff_Ioi : Ioi a \ Ioi b = Ioc a b 
goal: Set.Ioi a \ Set.Ioi b = Set.Ioc a b

full_name: Set.Ioi_diff_Ici
code: @[simp]
theorem Ioi_diff_Ici : Ioi a \ Ici b = Ioo a b 
goal: Set.Ioi a \ Set.Ici b = Set.Ioo a b

full_name: Set.Iic_diff_Iic
code: @[simp]
theorem Iic_diff_Iic : Iic b \ Iic a = Ioc a b 
goal: Set.Iic b \ Set.Iic a = Set.Ioc a b

full_name: Set.Iio_diff_Iic
code: @[simp]
theorem Iio_diff_Iic : Iio b \ Iic a = Ioo a b 
goal: Set.Iio b \ Set.Iic a = Set.Ioo a b

full_name: Set.Iic_diff_Iio
code: @[simp]
theorem Iic_diff_Iio : Iic b \ Iio a = Icc a b 
goal: Set.Iic b \ Set.Iio a = Set.Icc a b

full_name: Set.Iio_diff_Iio
code: @[simp]
theorem Iio_diff_Iio : Iio b \ Iio a = Ico a b 
goal: Set.Iio b \ Set.Iio a = Set.Ico a b

full_name: Set.Ioi_injective
code: theorem Ioi_injective : Injective (Ioi : α → Set α) 
goal: Function.Injective Set.Ioi

full_name: Set.Iio_injective
code: theorem Iio_injective : Injective (Iio : α → Set α) 
goal: Function.Injective Set.Iio

full_name: Set.Ioi_inj
code: theorem Ioi_inj : Ioi a = Ioi b ↔ a = b 
goal: Set.Ioi a = Set.Ioi b ↔ a = b

full_name: Set.Iio_inj
code: theorem Iio_inj : Iio a = Iio b ↔ a = b 
goal: Set.Iio a = Set.Iio b ↔ a = b

full_name: Set.Ico_subset_Ico_iff
code: theorem Ico_subset_Ico_iff (h₁ : a₁ < b₁) : Ico a₁ b₁ ⊆ Ico a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂ 
goal: Set.Ico a₁ b₁ ⊆ Set.Ico a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂

full_name: Set.Ioc_subset_Ioc_iff
code: theorem Ioc_subset_Ioc_iff (h₁ : a₁ < b₁) : Ioc a₁ b₁ ⊆ Ioc a₂ b₂ ↔ b₁ ≤ b₂ ∧ a₂ ≤ a₁ 
goal: Set.Ioc a₁ b₁ ⊆ Set.Ioc a₂ b₂ ↔ b₁ ≤ b₂ ∧ a₂ ≤ a₁

full_name: Set.Ioo_subset_Ioo_iff
code: theorem Ioo_subset_Ioo_iff [DenselyOrdered α] (h₁ : a₁ < b₁) :
    Ioo a₁ b₁ ⊆ Ioo a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂ 
goal: Set.Ioo a₁ b₁ ⊆ Set.Ioo a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ ≤ b₂

full_name: Set.Ico_eq_Ico_iff
code: theorem Ico_eq_Ico_iff (h : a₁ < b₁ ∨ a₂ < b₂) : Ico a₁ b₁ = Ico a₂ b₂ ↔ a₁ = a₂ ∧ b₁ = b₂ 
goal: Set.Ico a₁ b₁ = Set.Ico a₂ b₂ ↔ a₁ = a₂ ∧ b₁ = b₂

full_name: Set.Ici_eq_singleton_iff_isTop
code: lemma Ici_eq_singleton_iff_isTop {x : α} : (Ici x = {x}) ↔ IsTop x 
goal: Set.Ici x = {x} ↔ IsTop x

full_name: Set.Ioi_subset_Ioi_iff
code: @[simp]
theorem Ioi_subset_Ioi_iff : Ioi b ⊆ Ioi a ↔ a ≤ b 
goal: Set.Ioi b ⊆ Set.Ioi a ↔ a ≤ b

full_name: Set.Ioi_subset_Ici_iff
code: @[simp]
theorem Ioi_subset_Ici_iff [DenselyOrdered α] : Ioi b ⊆ Ici a ↔ a ≤ b 
goal: Set.Ioi b ⊆ Set.Ici a ↔ a ≤ b

full_name: Set.Iio_subset_Iio_iff
code: @[simp]
theorem Iio_subset_Iio_iff : Iio a ⊆ Iio b ↔ a ≤ b 
goal: Set.Iio a ⊆ Set.Iio b ↔ a ≤ b

full_name: Set.Iio_subset_Iic_iff
code: @[simp]
theorem Iio_subset_Iic_iff [DenselyOrdered α] : Iio a ⊆ Iic b ↔ a ≤ b 
goal: Set.Iio a ⊆ Set.Iic b ↔ a ≤ b

full_name: Set.Iic_union_Ioi_of_le
code: theorem Iic_union_Ioi_of_le (h : a ≤ b) : Iic b ∪ Ioi a = univ 
goal: Set.Iic b ∪ Set.Ioi a = Set.univ

full_name: Set.Iio_union_Ici_of_le
code: theorem Iio_union_Ici_of_le (h : a ≤ b) : Iio b ∪ Ici a = univ 
goal: Set.Iio b ∪ Set.Ici a = Set.univ

full_name: Set.Iic_union_Ici_of_le
code: theorem Iic_union_Ici_of_le (h : a ≤ b) : Iic b ∪ Ici a = univ 
goal: Set.Iic b ∪ Set.Ici a = Set.univ

full_name: Set.Iio_union_Ioi_of_lt
code: theorem Iio_union_Ioi_of_lt (h : a < b) : Iio b ∪ Ioi a = univ 
goal: Set.Iio b ∪ Set.Ioi a = Set.univ

full_name: Set.Iic_union_Ici
code: @[simp]
theorem Iic_union_Ici : Iic a ∪ Ici a = univ 
goal: Set.Iic a ∪ Set.Ici a = Set.univ

full_name: Set.Iio_union_Ici
code: @[simp]
theorem Iio_union_Ici : Iio a ∪ Ici a = univ 
goal: Set.Iio a ∪ Set.Ici a = Set.univ

full_name: Set.Iic_union_Ioi
code: @[simp]
theorem Iic_union_Ioi : Iic a ∪ Ioi a = univ 
goal: Set.Iic a ∪ Set.Ioi a = Set.univ

full_name: Set.Iio_union_Ioi
code: @[simp]
theorem Iio_union_Ioi : Iio a ∪ Ioi a = {a}ᶜ 
goal: Set.Iio a ∪ Set.Ioi a = {a}ᶜ

full_name: Set.Ioo_union_Ioi'
code: theorem Ioo_union_Ioi' (h₁ : c < b) : Ioo a b ∪ Ioi c = Ioi (min a c) 
goal: Set.Ioo a b ∪ Set.Ioi c = Set.Ioi (min a c)

full_name: Set.Ioo_union_Ioi
code: theorem Ioo_union_Ioi (h : c < max a b) : Ioo a b ∪ Ioi c = Ioi (min a c) 
goal: Set.Ioo a b ∪ Set.Ioi c = Set.Ioi (min a c)

full_name: Set.Ioi_subset_Ioo_union_Ici
code: theorem Ioi_subset_Ioo_union_Ici : Ioi a ⊆ Ioo a b ∪ Ici b 
goal: Set.Ioi a ⊆ Set.Ioo a b ∪ Set.Ici b

full_name: Set.Ioo_union_Ici_eq_Ioi
code: @[simp]
theorem Ioo_union_Ici_eq_Ioi (h : a < b) : Ioo a b ∪ Ici b = Ioi a 
goal: Set.Ioo a b ∪ Set.Ici b = Set.Ioi a

full_name: Set.Ici_subset_Ico_union_Ici
code: theorem Ici_subset_Ico_union_Ici : Ici a ⊆ Ico a b ∪ Ici b 
goal: Set.Ici a ⊆ Set.Ico a b ∪ Set.Ici b

full_name: Set.Ico_union_Ici_eq_Ici
code: @[simp]
theorem Ico_union_Ici_eq_Ici (h : a ≤ b) : Ico a b ∪ Ici b = Ici a 
goal: Set.Ico a b ∪ Set.Ici b = Set.Ici a

full_name: Set.Ico_union_Ici'
code: theorem Ico_union_Ici' (h₁ : c ≤ b) : Ico a b ∪ Ici c = Ici (min a c) 
goal: Set.Ico a b ∪ Set.Ici c = Set.Ici (min a c)

full_name: Set.Ico_union_Ici
code: theorem Ico_union_Ici (h : c ≤ max a b) : Ico a b ∪ Ici c = Ici (min a c) 
goal: Set.Ico a b ∪ Set.Ici c = Set.Ici (min a c)

full_name: Set.Ioi_subset_Ioc_union_Ioi
code: theorem Ioi_subset_Ioc_union_Ioi : Ioi a ⊆ Ioc a b ∪ Ioi b 
goal: Set.Ioi a ⊆ Set.Ioc a b ∪ Set.Ioi b

full_name: Set.Ioc_union_Ioi_eq_Ioi
code: @[simp]
theorem Ioc_union_Ioi_eq_Ioi (h : a ≤ b) : Ioc a b ∪ Ioi b = Ioi a 
goal: Set.Ioc a b ∪ Set.Ioi b = Set.Ioi a

full_name: Set.Ioc_union_Ioi'
code: theorem Ioc_union_Ioi' (h₁ : c ≤ b) : Ioc a b ∪ Ioi c = Ioi (min a c) 
goal: Set.Ioc a b ∪ Set.Ioi c = Set.Ioi (min a c)

full_name: Set.Ioc_union_Ioi
code: theorem Ioc_union_Ioi (h : c ≤ max a b) : Ioc a b ∪ Ioi c = Ioi (min a c) 
goal: Set.Ioc a b ∪ Set.Ioi c = Set.Ioi (min a c)

full_name: Set.Ici_subset_Icc_union_Ioi
code: theorem Ici_subset_Icc_union_Ioi : Ici a ⊆ Icc a b ∪ Ioi b 
goal: Set.Ici a ⊆ Set.Icc a b ∪ Set.Ioi b

full_name: Set.Icc_union_Ioi_eq_Ici
code: @[simp]
theorem Icc_union_Ioi_eq_Ici (h : a ≤ b) : Icc a b ∪ Ioi b = Ici a 
goal: Set.Icc a b ∪ Set.Ioi b = Set.Ici a

full_name: Set.Ioi_subset_Ioc_union_Ici
code: theorem Ioi_subset_Ioc_union_Ici : Ioi a ⊆ Ioc a b ∪ Ici b 
goal: Set.Ioi a ⊆ Set.Ioc a b ∪ Set.Ici b

full_name: Set.Ioc_union_Ici_eq_Ioi
code: @[simp]
theorem Ioc_union_Ici_eq_Ioi (h : a < b) : Ioc a b ∪ Ici b = Ioi a 
goal: Set.Ioc a b ∪ Set.Ici b = Set.Ioi a

full_name: Set.Ici_subset_Icc_union_Ici
code: theorem Ici_subset_Icc_union_Ici : Ici a ⊆ Icc a b ∪ Ici b 
goal: Set.Ici a ⊆ Set.Icc a b ∪ Set.Ici b

full_name: Set.Icc_union_Ici_eq_Ici
code: @[simp]
theorem Icc_union_Ici_eq_Ici (h : a ≤ b) : Icc a b ∪ Ici b = Ici a 
goal: Set.Icc a b ∪ Set.Ici b = Set.Ici a

full_name: Set.Icc_union_Ici'
code: theorem Icc_union_Ici' (h₁ : c ≤ b) : Icc a b ∪ Ici c = Ici (min a c) 
goal: Set.Icc a b ∪ Set.Ici c = Set.Ici (min a c)

full_name: Set.Icc_union_Ici
code: theorem Icc_union_Ici (h : c ≤ max a b) : Icc a b ∪ Ici c = Ici (min a c) 
goal: Set.Icc a b ∪ Set.Ici c = Set.Ici (min a c)

full_name: Set.Iic_subset_Iio_union_Icc
code: theorem Iic_subset_Iio_union_Icc : Iic b ⊆ Iio a ∪ Icc a b 
goal: Set.Iic b ⊆ Set.Iio a ∪ Set.Icc a b

full_name: Set.Iio_union_Icc_eq_Iic
code: @[simp]
theorem Iio_union_Icc_eq_Iic (h : a ≤ b) : Iio a ∪ Icc a b = Iic b 
goal: Set.Iio a ∪ Set.Icc a b = Set.Iic b

full_name: Set.Iio_subset_Iio_union_Ico
code: theorem Iio_subset_Iio_union_Ico : Iio b ⊆ Iio a ∪ Ico a b 
goal: Set.Iio b ⊆ Set.Iio a ∪ Set.Ico a b

full_name: Set.Iio_union_Ico_eq_Iio
code: @[simp]
theorem Iio_union_Ico_eq_Iio (h : a ≤ b) : Iio a ∪ Ico a b = Iio b 
goal: Set.Iio a ∪ Set.Ico a b = Set.Iio b

full_name: Set.Iio_union_Ico'
code: theorem Iio_union_Ico' (h₁ : c ≤ b) : Iio b ∪ Ico c d = Iio (max b d) 
goal: Set.Iio b ∪ Set.Ico c d = Set.Iio (max b d)

full_name: Set.Iio_union_Ico
code: theorem Iio_union_Ico (h : min c d ≤ b) : Iio b ∪ Ico c d = Iio (max b d) 
goal: Set.Iio b ∪ Set.Ico c d = Set.Iio (max b d)

full_name: Set.Iic_subset_Iic_union_Ioc
code: theorem Iic_subset_Iic_union_Ioc : Iic b ⊆ Iic a ∪ Ioc a b 
goal: Set.Iic b ⊆ Set.Iic a ∪ Set.Ioc a b

full_name: Set.Iic_union_Ioc_eq_Iic
code: @[simp]
theorem Iic_union_Ioc_eq_Iic (h : a ≤ b) : Iic a ∪ Ioc a b = Iic b 
goal: Set.Iic a ∪ Set.Ioc a b = Set.Iic b

full_name: Set.Iic_union_Ioc'
code: theorem Iic_union_Ioc' (h₁ : c < b) : Iic b ∪ Ioc c d = Iic (max b d) 
goal: Set.Iic b ∪ Set.Ioc c d = Set.Iic (max b d)

full_name: Set.Iic_union_Ioc
code: theorem Iic_union_Ioc (h : min c d < b) : Iic b ∪ Ioc c d = Iic (max b d) 
goal: Set.Iic b ∪ Set.Ioc c d = Set.Iic (max b d)

full_name: Set.Iio_subset_Iic_union_Ioo
code: theorem Iio_subset_Iic_union_Ioo : Iio b ⊆ Iic a ∪ Ioo a b 
goal: Set.Iio b ⊆ Set.Iic a ∪ Set.Ioo a b

full_name: Set.Iic_union_Ioo_eq_Iio
code: @[simp]
theorem Iic_union_Ioo_eq_Iio (h : a < b) : Iic a ∪ Ioo a b = Iio b 
goal: Set.Iic a ∪ Set.Ioo a b = Set.Iio b

full_name: Set.Iio_union_Ioo'
code: theorem Iio_union_Ioo' (h₁ : c < b) : Iio b ∪ Ioo c d = Iio (max b d) 
goal: Set.Iio b ∪ Set.Ioo c d = Set.Iio (max b d)

full_name: Set.Iio_union_Ioo
code: theorem Iio_union_Ioo (h : min c d < b) : Iio b ∪ Ioo c d = Iio (max b d) 
goal: Set.Iio b ∪ Set.Ioo c d = Set.Iio (max b d)

full_name: Set.Iic_subset_Iic_union_Icc
code: theorem Iic_subset_Iic_union_Icc : Iic b ⊆ Iic a ∪ Icc a b 
goal: Set.Iic b ⊆ Set.Iic a ∪ Set.Icc a b

full_name: Set.Iic_union_Icc_eq_Iic
code: @[simp]
theorem Iic_union_Icc_eq_Iic (h : a ≤ b) : Iic a ∪ Icc a b = Iic b 
goal: Set.Iic a ∪ Set.Icc a b = Set.Iic b

full_name: Set.Iic_union_Icc'
code: theorem Iic_union_Icc' (h₁ : c ≤ b) : Iic b ∪ Icc c d = Iic (max b d) 
goal: Set.Iic b ∪ Set.Icc c d = Set.Iic (max b d)

full_name: Set.Iic_union_Icc
code: theorem Iic_union_Icc (h : min c d ≤ b) : Iic b ∪ Icc c d = Iic (max b d) 
goal: Set.Iic b ∪ Set.Icc c d = Set.Iic (max b d)

full_name: Set.Iio_subset_Iic_union_Ico
code: theorem Iio_subset_Iic_union_Ico : Iio b ⊆ Iic a ∪ Ico a b 
goal: Set.Iio b ⊆ Set.Iic a ∪ Set.Ico a b

full_name: Set.Iic_union_Ico_eq_Iio
code: @[simp]
theorem Iic_union_Ico_eq_Iio (h : a < b) : Iic a ∪ Ico a b = Iio b 
goal: Set.Iic a ∪ Set.Ico a b = Set.Iio b

full_name: Set.Ioo_subset_Ioo_union_Ico
code: theorem Ioo_subset_Ioo_union_Ico : Ioo a c ⊆ Ioo a b ∪ Ico b c 
goal: Set.Ioo a c ⊆ Set.Ioo a b ∪ Set.Ico b c

full_name: Set.Ioo_union_Ico_eq_Ioo
code: @[simp]
theorem Ioo_union_Ico_eq_Ioo (h₁ : a < b) (h₂ : b ≤ c) : Ioo a b ∪ Ico b c = Ioo a c 
goal: Set.Ioo a b ∪ Set.Ico b c = Set.Ioo a c

full_name: Set.Ico_subset_Ico_union_Ico
code: theorem Ico_subset_Ico_union_Ico : Ico a c ⊆ Ico a b ∪ Ico b c 
goal: Set.Ico a c ⊆ Set.Ico a b ∪ Set.Ico b c

full_name: Set.Ico_union_Ico_eq_Ico
code: @[simp]
theorem Ico_union_Ico_eq_Ico (h₁ : a ≤ b) (h₂ : b ≤ c) : Ico a b ∪ Ico b c = Ico a c 
goal: Set.Ico a b ∪ Set.Ico b c = Set.Ico a c

full_name: Set.Ico_union_Ico'
code: theorem Ico_union_Ico' (h₁ : c ≤ b) (h₂ : a ≤ d) : Ico a b ∪ Ico c d = Ico (min a c) (max b d) 
goal: Set.Ico a b ∪ Set.Ico c d = Set.Ico (min a c) (max b d)

full_name: Set.Ico_union_Ico
code: theorem Ico_union_Ico (h₁ : min a b ≤ max c d) (h₂ : min c d ≤ max a b) :
    Ico a b ∪ Ico c d = Ico (min a c) (max b d) 
goal: Set.Ico a b ∪ Set.Ico c d = Set.Ico (min a c) (max b d)

full_name: Set.Icc_subset_Ico_union_Icc
code: theorem Icc_subset_Ico_union_Icc : Icc a c ⊆ Ico a b ∪ Icc b c 
goal: Set.Icc a c ⊆ Set.Ico a b ∪ Set.Icc b c

full_name: Set.Ico_union_Icc_eq_Icc
code: @[simp]
theorem Ico_union_Icc_eq_Icc (h₁ : a ≤ b) (h₂ : b ≤ c) : Ico a b ∪ Icc b c = Icc a c 
goal: Set.Ico a b ∪ Set.Icc b c = Set.Icc a c

full_name: Set.Ioc_subset_Ioo_union_Icc
code: theorem Ioc_subset_Ioo_union_Icc : Ioc a c ⊆ Ioo a b ∪ Icc b c 
goal: Set.Ioc a c ⊆ Set.Ioo a b ∪ Set.Icc b c

full_name: Set.Ioo_union_Icc_eq_Ioc
code: @[simp]
theorem Ioo_union_Icc_eq_Ioc (h₁ : a < b) (h₂ : b ≤ c) : Ioo a b ∪ Icc b c = Ioc a c 
goal: Set.Ioo a b ∪ Set.Icc b c = Set.Ioc a c

full_name: Set.Ioo_subset_Ioc_union_Ioo
code: theorem Ioo_subset_Ioc_union_Ioo : Ioo a c ⊆ Ioc a b ∪ Ioo b c 
goal: Set.Ioo a c ⊆ Set.Ioc a b ∪ Set.Ioo b c

full_name: Set.Ioc_union_Ioo_eq_Ioo
code: @[simp]
theorem Ioc_union_Ioo_eq_Ioo (h₁ : a ≤ b) (h₂ : b < c) : Ioc a b ∪ Ioo b c = Ioo a c 
goal: Set.Ioc a b ∪ Set.Ioo b c = Set.Ioo a c

full_name: Set.Ico_subset_Icc_union_Ioo
code: theorem Ico_subset_Icc_union_Ioo : Ico a c ⊆ Icc a b ∪ Ioo b c 
goal: Set.Ico a c ⊆ Set.Icc a b ∪ Set.Ioo b c

full_name: Set.Icc_union_Ioo_eq_Ico
code: @[simp]
theorem Icc_union_Ioo_eq_Ico (h₁ : a ≤ b) (h₂ : b < c) : Icc a b ∪ Ioo b c = Ico a c 
goal: Set.Icc a b ∪ Set.Ioo b c = Set.Ico a c

full_name: Set.Icc_subset_Icc_union_Ioc
code: theorem Icc_subset_Icc_union_Ioc : Icc a c ⊆ Icc a b ∪ Ioc b c 
goal: Set.Icc a c ⊆ Set.Icc a b ∪ Set.Ioc b c

full_name: Set.Icc_union_Ioc_eq_Icc
code: @[simp]
theorem Icc_union_Ioc_eq_Icc (h₁ : a ≤ b) (h₂ : b ≤ c) : Icc a b ∪ Ioc b c = Icc a c 
goal: Set.Icc a b ∪ Set.Ioc b c = Set.Icc a c

full_name: Set.Ioc_subset_Ioc_union_Ioc
code: theorem Ioc_subset_Ioc_union_Ioc : Ioc a c ⊆ Ioc a b ∪ Ioc b c 
goal: Set.Ioc a c ⊆ Set.Ioc a b ∪ Set.Ioc b c

full_name: Set.Ioc_union_Ioc_eq_Ioc
code: @[simp]
theorem Ioc_union_Ioc_eq_Ioc (h₁ : a ≤ b) (h₂ : b ≤ c) : Ioc a b ∪ Ioc b c = Ioc a c 
goal: Set.Ioc a b ∪ Set.Ioc b c = Set.Ioc a c

full_name: Set.Ioc_union_Ioc'
code: theorem Ioc_union_Ioc' (h₁ : c ≤ b) (h₂ : a ≤ d) : Ioc a b ∪ Ioc c d = Ioc (min a c) (max b d) 
goal: Set.Ioc a b ∪ Set.Ioc c d = Set.Ioc (min a c) (max b d)

full_name: Set.Ioc_union_Ioc
code: theorem Ioc_union_Ioc (h₁ : min a b ≤ max c d) (h₂ : min c d ≤ max a b) :
    Ioc a b ∪ Ioc c d = Ioc (min a c) (max b d) 
goal: Set.Ioc a b ∪ Set.Ioc c d = Set.Ioc (min a c) (max b d)

full_name: Set.Ioo_subset_Ioc_union_Ico
code: theorem Ioo_subset_Ioc_union_Ico : Ioo a c ⊆ Ioc a b ∪ Ico b c 
goal: Set.Ioo a c ⊆ Set.Ioc a b ∪ Set.Ico b c

full_name: Set.Ioc_union_Ico_eq_Ioo
code: @[simp]
theorem Ioc_union_Ico_eq_Ioo (h₁ : a < b) (h₂ : b < c) : Ioc a b ∪ Ico b c = Ioo a c 
goal: Set.Ioc a b ∪ Set.Ico b c = Set.Ioo a c

full_name: Set.Ico_subset_Icc_union_Ico
code: theorem Ico_subset_Icc_union_Ico : Ico a c ⊆ Icc a b ∪ Ico b c 
goal: Set.Ico a c ⊆ Set.Icc a b ∪ Set.Ico b c

full_name: Set.Icc_union_Ico_eq_Ico
code: @[simp]
theorem Icc_union_Ico_eq_Ico (h₁ : a ≤ b) (h₂ : b < c) : Icc a b ∪ Ico b c = Ico a c 
goal: Set.Icc a b ∪ Set.Ico b c = Set.Ico a c

full_name: Set.Icc_subset_Icc_union_Icc
code: theorem Icc_subset_Icc_union_Icc : Icc a c ⊆ Icc a b ∪ Icc b c 
goal: Set.Icc a c ⊆ Set.Icc a b ∪ Set.Icc b c

full_name: Set.Icc_union_Icc_eq_Icc
code: @[simp]
theorem Icc_union_Icc_eq_Icc (h₁ : a ≤ b) (h₂ : b ≤ c) : Icc a b ∪ Icc b c = Icc a c 
goal: Set.Icc a b ∪ Set.Icc b c = Set.Icc a c

full_name: Set.Icc_union_Icc'
code: theorem Icc_union_Icc' (h₁ : c ≤ b) (h₂ : a ≤ d) : Icc a b ∪ Icc c d = Icc (min a c) (max b d) 
goal: Set.Icc a b ∪ Set.Icc c d = Set.Icc (min a c) (max b d)

full_name: Set.Icc_union_Icc
code: /-- We cannot replace `<` by `≤` in the hypotheses.
Otherwise for `b < a = d < c` the l.h.s. is `∅` and the r.h.s. is `{a}`.
-/
theorem Icc_union_Icc (h₁ : min a b < max c d) (h₂ : min c d < max a b) :
    Icc a b ∪ Icc c d = Icc (min a c) (max b d) 
goal: Set.Icc a b ∪ Set.Icc c d = Set.Icc (min a c) (max b d)

full_name: Set.Ioc_subset_Ioc_union_Icc
code: theorem Ioc_subset_Ioc_union_Icc : Ioc a c ⊆ Ioc a b ∪ Icc b c 
goal: Set.Ioc a c ⊆ Set.Ioc a b ∪ Set.Icc b c

full_name: Set.Ioc_union_Icc_eq_Ioc
code: @[simp]
theorem Ioc_union_Icc_eq_Ioc (h₁ : a < b) (h₂ : b ≤ c) : Ioc a b ∪ Icc b c = Ioc a c 
goal: Set.Ioc a b ∪ Set.Icc b c = Set.Ioc a c

full_name: Set.Ioo_union_Ioo'
code: theorem Ioo_union_Ioo' (h₁ : c < b) (h₂ : a < d) : Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d) 
goal: Set.Ioo a b ∪ Set.Ioo c d = Set.Ioo (min a c) (max b d)

full_name: Set.Ioo_union_Ioo
code: theorem Ioo_union_Ioo (h₁ : min a b < max c d) (h₂ : min c d < max a b) :
    Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d) 
goal: Set.Ioo a b ∪ Set.Ioo c d = Set.Ioo (min a c) (max b d)

full_name: Set.Iic_inter_Iic
code: @[simp]
theorem Iic_inter_Iic {a b : α} : Iic a ∩ Iic b = Iic (a ⊓ b) 
goal: Set.Iic a ∩ Set.Iic b = Set.Iic (a ⊓ b)

full_name: Set.Ioc_inter_Iic
code: @[simp]
theorem Ioc_inter_Iic (a b c : α) : Ioc a b ∩ Iic c = Ioc a (b ⊓ c) 
goal: Set.Ioc a b ∩ Set.Iic c = Set.Ioc a (b ⊓ c)

full_name: Set.Ici_inter_Ici
code: @[simp]
theorem Ici_inter_Ici {a b : α} : Ici a ∩ Ici b = Ici (a ⊔ b) 
goal: Set.Ici a ∩ Set.Ici b = Set.Ici (a ⊔ b)

full_name: Set.Ico_inter_Ici
code: @[simp]
theorem Ico_inter_Ici (a b c : α) : Ico a b ∩ Ici c = Ico (a ⊔ c) b 
goal: Set.Ico a b ∩ Set.Ici c = Set.Ico (a ⊔ c) b

full_name: Set.Icc_inter_Icc
code: theorem Icc_inter_Icc : Icc a₁ b₁ ∩ Icc a₂ b₂ = Icc (a₁ ⊔ a₂) (b₁ ⊓ b₂) 
goal: Set.Icc a₁ b₁ ∩ Set.Icc a₂ b₂ = Set.Icc (a₁ ⊔ a₂) (b₁ ⊓ b₂)

full_name: Set.Icc_inter_Icc_eq_singleton
code: @[simp]
theorem Icc_inter_Icc_eq_singleton (hab : a ≤ b) (hbc : b ≤ c) : Icc a b ∩ Icc b c = {b} 
goal: Set.Icc a b ∩ Set.Icc b c = {b}

full_name: Set.Ioi_inter_Ioi
code: @[simp]
theorem Ioi_inter_Ioi : Ioi a ∩ Ioi b = Ioi (a ⊔ b) 
goal: Set.Ioi a ∩ Set.Ioi b = Set.Ioi (a ⊔ b)

full_name: Set.Iio_inter_Iio
code: @[simp]
theorem Iio_inter_Iio : Iio a ∩ Iio b = Iio (a ⊓ b) 
goal: Set.Iio a ∩ Set.Iio b = Set.Iio (a ⊓ b)

full_name: Set.Ico_inter_Ico
code: theorem Ico_inter_Ico : Ico a₁ b₁ ∩ Ico a₂ b₂ = Ico (a₁ ⊔ a₂) (b₁ ⊓ b₂) 
goal: Set.Ico a₁ b₁ ∩ Set.Ico a₂ b₂ = Set.Ico (a₁ ⊔ a₂) (b₁ ⊓ b₂)

full_name: Set.Ioc_inter_Ioc
code: theorem Ioc_inter_Ioc : Ioc a₁ b₁ ∩ Ioc a₂ b₂ = Ioc (a₁ ⊔ a₂) (b₁ ⊓ b₂) 
goal: Set.Ioc a₁ b₁ ∩ Set.Ioc a₂ b₂ = Set.Ioc (a₁ ⊔ a₂) (b₁ ⊓ b₂)

full_name: Set.Ioo_inter_Ioo
code: theorem Ioo_inter_Ioo : Ioo a₁ b₁ ∩ Ioo a₂ b₂ = Ioo (a₁ ⊔ a₂) (b₁ ⊓ b₂) 
goal: Set.Ioo a₁ b₁ ∩ Set.Ioo a₂ b₂ = Set.Ioo (a₁ ⊔ a₂) (b₁ ⊓ b₂)

full_name: Set.Ioo_inter_Iio
code: theorem Ioo_inter_Iio : Ioo a b ∩ Iio c = Ioo a (min b c) 
goal: Set.Ioo a b ∩ Set.Iio c = Set.Ioo a (min b c)

full_name: Set.Iio_inter_Ioo
code: theorem Iio_inter_Ioo : Iio a ∩ Ioo b c = Ioo b (min a c) 
goal: Set.Iio a ∩ Set.Ioo b c = Set.Ioo b (min a c)

full_name: Set.Ioo_inter_Ioi
code: theorem Ioo_inter_Ioi : Ioo a b ∩ Ioi c = Ioo (max a c) b 
goal: Set.Ioo a b ∩ Set.Ioi c = Set.Ioo (max a c) b

full_name: Set.Ioi_inter_Ioo
code: theorem Ioi_inter_Ioo : Set.Ioi a ∩ Set.Ioo b c = Set.Ioo (max a b) c 
goal: Set.Ioi a ∩ Set.Ioo b c = Set.Ioo (max a b) c

full_name: Set.Ioc_inter_Ioo_of_left_lt
code: theorem Ioc_inter_Ioo_of_left_lt (h : b₁ < b₂) : Ioc a₁ b₁ ∩ Ioo a₂ b₂ = Ioc (max a₁ a₂) b₁ 
goal: Set.Ioc a₁ b₁ ∩ Set.Ioo a₂ b₂ = Set.Ioc (max a₁ a₂) b₁

full_name: Set.Ioc_inter_Ioo_of_right_le
code: theorem Ioc_inter_Ioo_of_right_le (h : b₂ ≤ b₁) : Ioc a₁ b₁ ∩ Ioo a₂ b₂ = Ioo (max a₁ a₂) b₂ 
goal: Set.Ioc a₁ b₁ ∩ Set.Ioo a₂ b₂ = Set.Ioo (max a₁ a₂) b₂

full_name: Set.Ioo_inter_Ioc_of_left_le
code: theorem Ioo_inter_Ioc_of_left_le (h : b₁ ≤ b₂) : Ioo a₁ b₁ ∩ Ioc a₂ b₂ = Ioo (max a₁ a₂) b₁ 
goal: Set.Ioo a₁ b₁ ∩ Set.Ioc a₂ b₂ = Set.Ioo (max a₁ a₂) b₁

full_name: Set.Ioo_inter_Ioc_of_right_lt
code: theorem Ioo_inter_Ioc_of_right_lt (h : b₂ < b₁) : Ioo a₁ b₁ ∩ Ioc a₂ b₂ = Ioc (max a₁ a₂) b₂ 
goal: Set.Ioo a₁ b₁ ∩ Set.Ioc a₂ b₂ = Set.Ioc (max a₁ a₂) b₂

full_name: Set.Ico_diff_Iio
code: @[simp]
theorem Ico_diff_Iio : Ico a b \ Iio c = Ico (max a c) b 
goal: Set.Ico a b \ Set.Iio c = Set.Ico (max a c) b

full_name: Set.Ioc_diff_Ioi
code: @[simp]
theorem Ioc_diff_Ioi : Ioc a b \ Ioi c = Ioc a (min b c) 
goal: Set.Ioc a b \ Set.Ioi c = Set.Ioc a (min b c)

full_name: Set.Ioc_inter_Ioi
code: @[simp]
theorem Ioc_inter_Ioi : Ioc a b ∩ Ioi c = Ioc (a ⊔ c) b 
goal: Set.Ioc a b ∩ Set.Ioi c = Set.Ioc (a ⊔ c) b

full_name: Set.Ico_inter_Iio
code: @[simp]
theorem Ico_inter_Iio : Ico a b ∩ Iio c = Ico a (min b c) 
goal: Set.Ico a b ∩ Set.Iio c = Set.Ico a (min b c)

full_name: Set.Ioc_diff_Iic
code: @[simp]
theorem Ioc_diff_Iic : Ioc a b \ Iic c = Ioc (max a c) b 
goal: Set.Ioc a b \ Set.Iic c = Set.Ioc (max a c) b

full_name: Set.Ioc_union_Ioc_right
code: @[simp]
theorem Ioc_union_Ioc_right : Ioc a b ∪ Ioc a c = Ioc a (max b c) 
goal: Set.Ioc a b ∪ Set.Ioc a c = Set.Ioc a (max b c)

full_name: Set.Ioc_union_Ioc_left
code: @[simp]
theorem Ioc_union_Ioc_left : Ioc a c ∪ Ioc b c = Ioc (min a b) c 
goal: Set.Ioc a c ∪ Set.Ioc b c = Set.Ioc (min a b) c

full_name: Set.Ioc_union_Ioc_symm
code: @[simp]
theorem Ioc_union_Ioc_symm : Ioc a b ∪ Ioc b a = Ioc (min a b) (max a b) 
goal: Set.Ioc a b ∪ Set.Ioc b a = Set.Ioc (min a b) (max a b)

full_name: Set.Ioc_union_Ioc_union_Ioc_cycle
code: @[simp]
theorem Ioc_union_Ioc_union_Ioc_cycle :
    Ioc a b ∪ Ioc b c ∪ Ioc c a = Ioc (min a (min b c)) (max a (max b c)) 
goal: Set.Ioc a b ∪ Set.Ioc b c ∪ Set.Ioc c a = Set.Ioc (min a (min b c)) (max a (max b c))

full_name: Set.Iic_prod_Iic
code: @[simp]
theorem Iic_prod_Iic (a : α) (b : β) : Iic a ×ˢ Iic b = Iic (a, b) 
goal: Set.Iic a ×ˢ Set.Iic b = Set.Iic (a, b)

full_name: Set.Ici_prod_Ici
code: @[simp]
theorem Ici_prod_Ici (a : α) (b : β) : Ici a ×ˢ Ici b = Ici (a, b) 
goal: Set.Ici a ×ˢ Set.Ici b = Set.Ici (a, b)

full_name: Set.Ici_prod_eq
code: theorem Ici_prod_eq (a : α × β) : Ici a = Ici a.1 ×ˢ Ici a.2 
goal: Set.Ici a = Set.Ici a.1 ×ˢ Set.Ici a.2

full_name: Set.Iic_prod_eq
code: theorem Iic_prod_eq (a : α × β) : Iic a = Iic a.1 ×ˢ Iic a.2 
goal: Set.Iic a = Set.Iic a.1 ×ˢ Set.Iic a.2

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

full_name: Set.Icc_prod_eq
code: theorem Icc_prod_eq (a b : α × β) : Icc a b = Icc a.1 b.1 ×ˢ Icc a.2 b.2 
goal: Set.Icc a b = Set.Icc a.1 b.1 ×ˢ Set.Icc a.2 b.2

full_name: instNoMinOrderElemIoo
code: instance : NoMinOrder (Set.Ioo x y) 
goal: NoMinOrder ↑(Set.Ioo x y)

full_name: instNoMinOrderElemIoc
code: instance : NoMinOrder (Set.Ioc x y) 
goal: NoMinOrder ↑(Set.Ioc x y)

full_name: instNoMinOrderElemIoi
code: instance : NoMinOrder (Set.Ioi x) 
goal: NoMinOrder ↑(Set.Ioi x)

full_name: instNoMaxOrderElemIoo
code: instance : NoMaxOrder (Set.Ioo x y) 
goal: NoMaxOrder ↑(Set.Ioo x y)

full_name: instNoMaxOrderElemIco
code: instance : NoMaxOrder (Set.Ico x y) 
goal: NoMaxOrder ↑(Set.Ico x y)

full_name: instNoMaxOrderElemIio
code: instance : NoMaxOrder (Set.Iio x) 
goal: NoMaxOrder ↑(Set.Iio x)