File: Mathlib/Order/Interval/Basic.lean

full_name: NonemptyInterval.fst_le_snd
code: /-- The nonempty closed intervals in an order.

We define intervals by the pair of endpoints `fst`, `snd`. To convert intervals to the set of
elements between these endpoints, use the coercion `NonemptyInterval α → Set α`. -/
@[ext (flat := false)]
structure NonemptyInterval (α : Type*) [LE α] extends Prod α α where
  /-- The starting point of an interval is smaller than the endpoint. -/
  fst_le_snd : fst ≤ snd
goal: self.toProd.1 ≤ self.toProd.2

full_name: NonemptyInterval
code: /-- The nonempty closed intervals in an order.

We define intervals by the pair of endpoints `fst`, `snd`. To convert intervals to the set of
elements between these endpoints, use the coercion `NonemptyInterval α → Set α`. -/
@[ext (flat := false)]
structure NonemptyInterval (α : Type*) [LE α] extends Prod α α where
  /-- The starting point of an interval is smaller than the endpoint. -/
  fst_le_snd : fst ≤ snd
goal: Type u_7

full_name: NonemptyInterval.toProd_injective
code: theorem toProd_injective : Injective (toProd : NonemptyInterval α → α × α) 
goal: Function.Injective NonemptyInterval.toProd

full_name: NonemptyInterval.toDualProd
code: /-- The injection that induces the order on intervals. -/
def toDualProd : NonemptyInterval α → αᵒᵈ × α 
goal: NonemptyInterval α → αᵒᵈ × α

full_name: NonemptyInterval.toDualProd_apply
code: @[simp]
theorem toDualProd_apply (s : NonemptyInterval α) : s.toDualProd = (toDual s.fst, s.snd) 
goal: s.toDualProd = (OrderDual.toDual s.toProd.1, s.toProd.2)

full_name: NonemptyInterval.toDualProd_injective
code: theorem toDualProd_injective : Injective (toDualProd : NonemptyInterval α → αᵒᵈ × α) 
goal: Function.Injective NonemptyInterval.toDualProd

full_name: NonemptyInterval.instIsEmpty
code: instance [IsEmpty α] : IsEmpty (NonemptyInterval α) 
goal: IsEmpty (NonemptyInterval α)

full_name: NonemptyInterval.instSubsingleton
code: instance [Subsingleton α] : Subsingleton (NonemptyInterval α) 
goal: Subsingleton (NonemptyInterval α)

full_name: NonemptyInterval.le
code: instance le : LE (NonemptyInterval α) 
goal: LE (NonemptyInterval α)

full_name: NonemptyInterval.le_def
code: theorem le_def : s ≤ t ↔ t.fst ≤ s.fst ∧ s.snd ≤ t.snd 
goal: s ≤ t ↔ t.toProd.1 ≤ s.toProd.1 ∧ s.toProd.2 ≤ t.toProd.2

full_name: NonemptyInterval.toDualProdHom
code: /-- `toDualProd` as an order embedding. -/
@[simps]
def toDualProdHom : NonemptyInterval α ↪o αᵒᵈ × α 
goal: NonemptyInterval α ↪o αᵒᵈ × α

full_name: NonemptyInterval.toDualProdHom_apply
code: /-- `toDualProd` as an order embedding. -/
@[simps]
def toDualProdHom : NonemptyInterval α ↪o αᵒᵈ × α 
goal: ∀ (a : NonemptyInterval α), NonemptyInterval.toDualProdHom a = a.toDualProd

full_name: NonemptyInterval.dual
code: /-- Turn an interval into an interval in the dual order. -/
def dual : NonemptyInterval α ≃ NonemptyInterval αᵒᵈ 
goal: NonemptyInterval α ≃ NonemptyInterval αᵒᵈ

full_name: NonemptyInterval.fst_dual
code: @[simp]
theorem fst_dual (s : NonemptyInterval α) : s.dual.fst = toDual s.snd 
goal: (NonemptyInterval.dual s).toProd.1 = OrderDual.toDual s.toProd.2

full_name: NonemptyInterval.snd_dual
code: @[simp]
theorem snd_dual (s : NonemptyInterval α) : s.dual.snd = toDual s.fst 
goal: (NonemptyInterval.dual s).toProd.2 = OrderDual.toDual s.toProd.1

full_name: NonemptyInterval.instPreorder
code: instance : Preorder (NonemptyInterval α) 
goal: Preorder (NonemptyInterval α)

full_name: NonemptyInterval.instCoeSet
code: instance : Coe (NonemptyInterval α) (Set α) 
goal: Coe (NonemptyInterval α) (Set α)

full_name: NonemptyInterval.instMembership
code: instance (priority := 100) : Membership α (NonemptyInterval α) 
goal: Membership α (NonemptyInterval α)

full_name: NonemptyInterval.mem_mk
code: @[simp]
theorem mem_mk {hx : x.1 ≤ x.2} : a ∈ mk x hx ↔ x.1 ≤ a ∧ a ≤ x.2 
goal: a ∈ { toProd := x, fst_le_snd := hx } ↔ x.1 ≤ a ∧ a ≤ x.2

full_name: NonemptyInterval.mem_def
code: theorem mem_def : a ∈ s ↔ s.fst ≤ a ∧ a ≤ s.snd 
goal: a ∈ s ↔ s.toProd.1 ≤ a ∧ a ≤ s.toProd.2

full_name: NonemptyInterval.coe_nonempty
code: theorem coe_nonempty (s : NonemptyInterval α) : (s : Set α).Nonempty 
goal: (Set.Icc s.toProd.1 s.toProd.2).Nonempty

full_name: NonemptyInterval.pure_snd
code: /-- `{a}` as an interval. -/
@[simps]
def pure (a : α) : NonemptyInterval α 
goal: (NonemptyInterval.pure a).toProd.2 = a

full_name: NonemptyInterval.pure_fst
code: /-- `{a}` as an interval. -/
@[simps]
def pure (a : α) : NonemptyInterval α 
goal: (NonemptyInterval.pure a).toProd.1 = a

full_name: NonemptyInterval.pure
code: /-- `{a}` as an interval. -/
@[simps]
def pure (a : α) : NonemptyInterval α 
goal: NonemptyInterval α

full_name: NonemptyInterval.mem_pure_self
code: theorem mem_pure_self (a : α) : a ∈ pure a 
goal: a ∈ NonemptyInterval.pure a

full_name: NonemptyInterval.pure_injective
code: theorem pure_injective : Injective (pure : α → NonemptyInterval α) 
goal: Function.Injective NonemptyInterval.pure

full_name: NonemptyInterval.dual_pure
code: @[simp]
theorem dual_pure (a : α) : dual (pure a) = pure (toDual a) 
goal: NonemptyInterval.dual (NonemptyInterval.pure a) = NonemptyInterval.pure (OrderDual.toDual a)

full_name: NonemptyInterval.instInhabited
code: instance [Inhabited α] : Inhabited (NonemptyInterval α) 
goal: Inhabited (NonemptyInterval α)

full_name: NonemptyInterval.instNonempty
code: instance [Nonempty α] : Nonempty (NonemptyInterval α) 
goal: Nonempty (NonemptyInterval α)

full_name: NonemptyInterval.instNontrivial
code: instance [Nontrivial α] : Nontrivial (NonemptyInterval α) 
goal: Nontrivial (NonemptyInterval α)

full_name: NonemptyInterval.map
code: /-- Pushforward of nonempty intervals. -/
@[simps!]
def map (f : α →o β) (a : NonemptyInterval α) : NonemptyInterval β 
goal: NonemptyInterval β

full_name: NonemptyInterval.map_fst
code: /-- Pushforward of nonempty intervals. -/
@[simps!]
def map (f : α →o β) (a : NonemptyInterval α) : NonemptyInterval β 
goal: (NonemptyInterval.map f a).toProd.1 = f a.1.1

full_name: NonemptyInterval.map_snd
code: /-- Pushforward of nonempty intervals. -/
@[simps!]
def map (f : α →o β) (a : NonemptyInterval α) : NonemptyInterval β 
goal: (NonemptyInterval.map f a).toProd.2 = f a.1.2

full_name: NonemptyInterval.map_pure
code: @[simp]
theorem map_pure (f : α →o β) (a : α) : (pure a).map f = pure (f a) 
goal: NonemptyInterval.map f (NonemptyInterval.pure a) = NonemptyInterval.pure (f a)

full_name: NonemptyInterval.map_map
code: @[simp]
theorem map_map (g : β →o γ) (f : α →o β) (a : NonemptyInterval α) :
    (a.map f).map g = a.map (g.comp f) 
goal: NonemptyInterval.map g (NonemptyInterval.map f a) = NonemptyInterval.map (g.comp f) a

full_name: NonemptyInterval.dual_map
code: @[simp]
theorem dual_map (f : α →o β) (a : NonemptyInterval α) :
    dual (a.map f) = a.dual.map (OrderHom.dual f) 
goal: NonemptyInterval.dual (NonemptyInterval.map f a) = NonemptyInterval.map (OrderHom.dual f) (NonemptyInterval.dual a)

full_name: NonemptyInterval.map₂
code: /-- Binary pushforward of nonempty intervals. -/
@[simps]
def map₂ (f : α → β → γ) (h₀ : ∀ b, Monotone fun a => f a b) (h₁ : ∀ a, Monotone (f a)) :
    NonemptyInterval α → NonemptyInterval β → NonemptyInterval γ 
goal: NonemptyInterval α → NonemptyInterval β → NonemptyInterval γ

full_name: NonemptyInterval.map₂_fst
code: /-- Binary pushforward of nonempty intervals. -/
@[simps]
def map₂ (f : α → β → γ) (h₀ : ∀ b, Monotone fun a => f a b) (h₁ : ∀ a, Monotone (f a)) :
    NonemptyInterval α → NonemptyInterval β → NonemptyInterval γ 
goal: ∀ (a : NonemptyInterval α) (a_1 : NonemptyInterval β),
  (NonemptyInterval.map₂ f h₀ h₁ a a_1).toProd.1 = f a.toProd.1 a_1.toProd.1

full_name: NonemptyInterval.map₂_snd
code: /-- Binary pushforward of nonempty intervals. -/
@[simps]
def map₂ (f : α → β → γ) (h₀ : ∀ b, Monotone fun a => f a b) (h₁ : ∀ a, Monotone (f a)) :
    NonemptyInterval α → NonemptyInterval β → NonemptyInterval γ 
goal: ∀ (a : NonemptyInterval α) (a_1 : NonemptyInterval β),
  (NonemptyInterval.map₂ f h₀ h₁ a a_1).toProd.2 = f a.toProd.2 a_1.toProd.2

full_name: NonemptyInterval.map₂_pure
code: @[simp]
theorem map₂_pure (f : α → β → γ) (h₀ h₁) (a : α) (b : β) :
    map₂ f h₀ h₁ (pure a) (pure b) = pure (f a b) 
goal: NonemptyInterval.map₂ f h₀ h₁ (NonemptyInterval.pure a) (NonemptyInterval.pure b) = NonemptyInterval.pure (f a b)

full_name: NonemptyInterval.dual_map₂
code: @[simp]
theorem dual_map₂ (f : α → β → γ) (h₀ h₁ s t) :
    dual (map₂ f h₀ h₁ s t) =
      map₂ (fun a b => toDual <| f (ofDual a) <| ofDual b) (fun _ => (h₀ _).dual)
        (fun _ => (h₁ _).dual) (dual s) (dual t) 
goal: NonemptyInterval.dual (NonemptyInterval.map₂ f h₀ h₁ s t) =
  NonemptyInterval.map₂ (fun a b => OrderDual.toDual (f (OrderDual.ofDual a) (OrderDual.ofDual b))) ⋯ ⋯
    (NonemptyInterval.dual s) (NonemptyInterval.dual t)

full_name: NonemptyInterval.instOrderTop
code: instance : OrderTop (NonemptyInterval α) 
goal: OrderTop (NonemptyInterval α)

full_name: NonemptyInterval.dual_top
code: @[simp]
theorem dual_top : dual (⊤ : NonemptyInterval α) = ⊤ 
goal: NonemptyInterval.dual ⊤ = ⊤

full_name: NonemptyInterval.instPartialOrder
code: instance : PartialOrder (NonemptyInterval α) 
goal: PartialOrder (NonemptyInterval α)

full_name: NonemptyInterval.coeHom
code: /-- Consider a nonempty interval `[a, b]` as the set `[a, b]`. -/
def coeHom : NonemptyInterval α ↪o Set α 
goal: NonemptyInterval α ↪o Set α

full_name: NonemptyInterval.setLike
code: instance setLike : SetLike (NonemptyInterval α) α 
goal: SetLike (NonemptyInterval α) α

full_name: NonemptyInterval.coe_subset_coe
code: @[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_subset_coe : (s : Set α) ⊆ t ↔ (s : NonemptyInterval α) ≤ t 
goal: ↑s ⊆ ↑t ↔ s ≤ t

full_name: NonemptyInterval.coe_ssubset_coe
code: @[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_ssubset_coe : (s : Set α) ⊂ t ↔ s < t 
goal: ↑s ⊂ ↑t ↔ s < t

full_name: NonemptyInterval.coe_coeHom
code: @[simp]
theorem coe_coeHom : (coeHom : NonemptyInterval α → Set α) = ((↑) : NonemptyInterval α → Set α) 
goal: ⇑NonemptyInterval.coeHom = SetLike.coe

full_name: NonemptyInterval.coe_def
code: theorem coe_def (s : NonemptyInterval α) : (s : Set α) = Set.Icc s.toProd.1 s.toProd.2 
goal: ↑s = Set.Icc s.toProd.1 s.toProd.2

full_name: NonemptyInterval.coe_pure
code: @[simp, norm_cast]
theorem coe_pure (a : α) : (pure a : Set α) = {a} 
goal: ↑(NonemptyInterval.pure a) = {a}

full_name: NonemptyInterval.mem_pure
code: @[simp]
theorem mem_pure : b ∈ pure a ↔ b = a 
goal: b ∈ NonemptyInterval.pure a ↔ b = a

full_name: NonemptyInterval.coe_top
code: @[simp, norm_cast]
theorem coe_top [BoundedOrder α] : ((⊤ : NonemptyInterval α) : Set α) = univ 
goal: ↑⊤ = Set.univ

full_name: NonemptyInterval.coe_dual
code: @[simp, norm_cast]
theorem coe_dual (s : NonemptyInterval α) : (dual s : Set αᵒᵈ) = ofDual ⁻¹' s 
goal: ↑(NonemptyInterval.dual s) = ⇑OrderDual.ofDual ⁻¹' ↑s

full_name: NonemptyInterval.subset_coe_map
code: theorem subset_coe_map (f : α →o β) (s : NonemptyInterval α) : f '' s ⊆ s.map f 
goal: ⇑f '' ↑s ⊆ ↑(NonemptyInterval.map f s)

full_name: NonemptyInterval.instSup
code: instance : Sup (NonemptyInterval α) 
goal: Sup (NonemptyInterval α)

full_name: NonemptyInterval.instSemilatticeSup
code: instance : SemilatticeSup (NonemptyInterval α) 
goal: SemilatticeSup (NonemptyInterval α)

full_name: NonemptyInterval.fst_sup
code: @[simp]
theorem fst_sup (s t : NonemptyInterval α) : (s ⊔ t).fst = s.fst ⊓ t.fst 
goal: (s ⊔ t).toProd.1 = s.toProd.1 ⊓ t.toProd.1

full_name: NonemptyInterval.snd_sup
code: @[simp]
theorem snd_sup (s t : NonemptyInterval α) : (s ⊔ t).snd = s.snd ⊔ t.snd 
goal: (s ⊔ t).toProd.2 = s.toProd.2 ⊔ t.toProd.2

full_name: Interval
code: /-- The closed intervals in an order.

We represent intervals either as `⊥` or a nonempty interval given by its endpoints `fst`, `snd`.
To convert intervals to the set of elements between these endpoints, use the coercion
`Interval α → Set α`. -/
-- Porting note: added reducible, it seems to help with coercions
abbrev Interval (α : Type*) [LE α] 
goal: Type u_7

full_name: Interval.instInhabited
code: instance : Inhabited (Interval α) 
goal: Inhabited (Interval α)

full_name: Interval.instLE
code: instance : LE (Interval α) 
goal: LE (Interval α)

full_name: Interval.instOrderBot
code: instance : OrderBot (Interval α) 
goal: OrderBot (Interval α)

full_name: Interval.instCoeNonemptyInterval
code: instance : Coe (NonemptyInterval α) (Interval α) 
goal: Coe (NonemptyInterval α) (Interval α)

full_name: Interval.canLift
code: instance canLift : CanLift (Interval α) (NonemptyInterval α) (↑) fun r => r ≠ ⊥ 
goal: CanLift (Interval α) (NonemptyInterval α) WithBot.some fun r => r ≠ ⊥

full_name: Interval.recBotCoe
code: /-- Recursor for `Interval` using the preferred forms `⊥` and `↑a`. -/
@[elab_as_elim, induction_eliminator, cases_eliminator]
def recBotCoe {C : Interval α → Sort*} (bot : C ⊥) (coe : ∀ a : NonemptyInterval α, C a) :
    ∀ n : Interval α, C n 
goal: C n

full_name: Interval.coe_injective
code: theorem coe_injective : Injective ((↑) : NonemptyInterval α → Interval α) 
goal: Function.Injective WithBot.some

full_name: Interval.coe_inj
code: @[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_inj {s t : NonemptyInterval α} : (s : Interval α) = t ↔ s = t 
goal: ↑s = ↑t ↔ s = t

full_name: Interval.forall
code: protected
theorem «forall» {p : Interval α → Prop} : (∀ s, p s) ↔ p ⊥ ∧ ∀ s : NonemptyInterval α, p s 
goal: (∀ (s : Interval α), p s) ↔ p ⊥ ∧ ∀ (s : NonemptyInterval α), p ↑s

full_name: Interval.exists
code: protected
theorem «exists» {p : Interval α → Prop} : (∃ s, p s) ↔ p ⊥ ∨ ∃ s : NonemptyInterval α, p s 
goal: (∃ s, p s) ↔ p ⊥ ∨ ∃ s, p ↑s

full_name: Interval.instUniqueOfIsEmpty
code: instance [IsEmpty α] : Unique (Interval α) 
goal: Unique (Interval α)

full_name: Interval.dual
code: /-- Turn an interval into an interval in the dual order. -/
def dual : Interval α ≃ Interval αᵒᵈ 
goal: Interval α ≃ Interval αᵒᵈ

full_name: Interval.instPreorder
code: instance : Preorder (Interval α) 
goal: Preorder (Interval α)

full_name: Interval.pure
code: /-- `{a}` as an interval. -/
def pure (a : α) : Interval α 
goal: Interval α

full_name: Interval.pure_injective
code: theorem pure_injective : Injective (pure : α → Interval α) 
goal: Function.Injective Interval.pure

full_name: Interval.dual_pure
code: @[simp]
theorem dual_pure (a : α) : dual (pure a) = pure (toDual a) 
goal: Interval.dual (Interval.pure a) = Interval.pure (OrderDual.toDual a)

full_name: Interval.dual_bot
code: @[simp]
theorem dual_bot : dual (⊥ : Interval α) = ⊥ 
goal: Interval.dual ⊥ = ⊥

full_name: Interval.pure_ne_bot
code: @[simp]
theorem pure_ne_bot {a : α} : pure a ≠ ⊥ 
goal: Interval.pure a ≠ ⊥

full_name: Interval.bot_ne_pure
code: @[simp]
theorem bot_ne_pure {a : α} : ⊥ ≠ pure a 
goal: ⊥ ≠ Interval.pure a

full_name: Interval.instNontrivialOfNonempty
code: instance [Nonempty α] : Nontrivial (Interval α) 
goal: Nontrivial (Interval α)

full_name: Interval.map
code: /-- Pushforward of intervals. -/
def map (f : α →o β) : Interval α → Interval β 
goal: Interval α → Interval β

full_name: Interval.map_pure
code: @[simp]
theorem map_pure (f : α →o β) (a : α) : (pure a).map f = pure (f a) 
goal: Interval.map f (Interval.pure a) = Interval.pure (f a)

full_name: Interval.map_map
code: @[simp]
theorem map_map (g : β →o γ) (f : α →o β) (s : Interval α) : (s.map f).map g = s.map (g.comp f) 
goal: Interval.map g (Interval.map f s) = Interval.map (g.comp f) s

full_name: Interval.dual_map
code: @[simp]
theorem dual_map (f : α →o β) (s : Interval α) : dual (s.map f) = s.dual.map (OrderHom.dual f) 
goal: Interval.dual (Interval.map f s) = Interval.map (OrderHom.dual f) (Interval.dual s)

full_name: Interval.boundedOrder
code: instance boundedOrder : BoundedOrder (Interval α) 
goal: BoundedOrder (Interval α)

full_name: Interval.dual_top
code: @[simp]
theorem dual_top : dual (⊤ : Interval α) = ⊤ 
goal: Interval.dual ⊤ = ⊤

full_name: Interval.partialOrder
code: instance partialOrder : PartialOrder (Interval α) 
goal: PartialOrder (Interval α)

full_name: Interval.coeHom
code: /-- Consider an interval `[a, b]` as the set `[a, b]`. -/
def coeHom : Interval α ↪o Set α 
goal: Interval α ↪o Set α

full_name: Interval.setLike
code: instance setLike : SetLike (Interval α) α 
goal: SetLike (Interval α) α

full_name: Interval.coe_subset_coe
code: @[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_subset_coe : (s : Set α) ⊆ t ↔ s ≤ t 
goal: ↑s ⊆ ↑t ↔ s ≤ t

full_name: Interval.coe_sSubset_coe
code: @[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_sSubset_coe : (s : Set α) ⊂ t ↔ s < t 
goal: ↑s ⊂ ↑t ↔ s < t

full_name: Interval.coe_pure
code: @[simp, norm_cast]
theorem coe_pure (a : α) : (pure a : Set α) = {a} 
goal: ↑(Interval.pure a) = {a}

full_name: Interval.coe_coe
code: @[simp, norm_cast]
theorem coe_coe (s : NonemptyInterval α) : ((s : Interval α) : Set α) = s 
goal: ↑↑s = ↑s

full_name: Interval.coe_bot
code: @[simp, norm_cast]
theorem coe_bot : ((⊥ : Interval α) : Set α) = ∅ 
goal: ↑⊥ = ∅

full_name: Interval.coe_top
code: @[simp, norm_cast]
theorem coe_top [BoundedOrder α] : ((⊤ : Interval α) : Set α) = univ 
goal: ↑⊤ = Set.univ

full_name: Interval.coe_dual
code: @[simp, norm_cast]
theorem coe_dual (s : Interval α) : (dual s : Set αᵒᵈ) = ofDual ⁻¹' s 
goal: ↑(Interval.dual s) = ⇑OrderDual.ofDual ⁻¹' ↑s

full_name: Interval.subset_coe_map
code: theorem subset_coe_map (f : α →o β) : ∀ s : Interval α, f '' s ⊆ s.map f
  
goal: ⇑f '' ↑s ⊆ ↑(Interval.map f s)

full_name: Interval.mem_pure
code: @[simp]
theorem mem_pure : b ∈ pure a ↔ b = a 
goal: b ∈ Interval.pure a ↔ b = a

full_name: Interval.mem_pure_self
code: theorem mem_pure_self (a : α) : a ∈ pure a 
goal: a ∈ Interval.pure a

full_name: Interval.semilatticeSup
code: instance semilatticeSup : SemilatticeSup (Interval α) 
goal: SemilatticeSup (Interval α)

full_name: Interval.lattice
code: instance lattice : Lattice (Interval α) 
goal: Lattice (Interval α)

full_name: Interval.coe_inf
code: @[simp, norm_cast]
theorem coe_inf : ∀ s t : Interval α, (↑(s ⊓ t) : Set α) = ↑s ∩ ↑t
  
goal: ↑(s ⊓ t) = ↑s ∩ ↑t

full_name: Interval.disjoint_coe
code: @[simp, norm_cast]
theorem disjoint_coe (s t : Interval α) : Disjoint (s : Set α) t ↔ Disjoint s t 
goal: Disjoint ↑s ↑t ↔ Disjoint s t

full_name: NonemptyInterval.coe_pure_interval
code: @[simp, norm_cast]
theorem coe_pure_interval (a : α) : (pure a : Interval α) = Interval.pure a 
goal: ↑(NonemptyInterval.pure a) = Interval.pure a

full_name: NonemptyInterval.coe_eq_pure
code: @[simp, norm_cast]
theorem coe_eq_pure : (s : Interval α) = Interval.pure a ↔ s = pure a 
goal: ↑s = Interval.pure a ↔ s = NonemptyInterval.pure a

full_name: NonemptyInterval.coe_top_interval
code: @[simp, norm_cast]
theorem coe_top_interval [BoundedOrder α] : ((⊤ : NonemptyInterval α) : Interval α) = ⊤ 
goal: ↑⊤ = ⊤

full_name: NonemptyInterval.mem_coe_interval
code: @[simp, norm_cast]
theorem mem_coe_interval [PartialOrder α] {s : NonemptyInterval α} {x : α} :
    x ∈ (s : Interval α) ↔ x ∈ s 
goal: x ∈ ↑s ↔ x ∈ s

full_name: NonemptyInterval.coe_sup_interval
code: @[simp, norm_cast]
theorem coe_sup_interval [Lattice α] (s t : NonemptyInterval α) :
    (↑(s ⊔ t) : Interval α) = ↑s ⊔ ↑t 
goal: ↑(s ⊔ t) = ↑s ⊔ ↑t

full_name: Interval.completeLattice
code: noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) 
goal: CompleteLattice (Interval α)

full_name: Interval.coe_sInf
code: @[simp, norm_cast]
theorem coe_sInf [@DecidableRel α (· ≤ ·)] (S : Set (Interval α)) :
    ↑(sInf S) = ⋂ s ∈ S, (s : Set α) 
goal: ↑(sInf S) = ⋂ s ∈ S, ↑s

full_name: Interval.coe_iInf
code: @[simp, norm_cast]
theorem coe_iInf [@DecidableRel α (· ≤ ·)] (f : ι → Interval α) :
    ↑(⨅ i, f i) = ⋂ i, (f i : Set α) 
goal: ↑(⨅ i, f i) = ⋂ i, ↑(f i)

full_name: Interval.coe_iInf₂
code: @[norm_cast]
theorem coe_iInf₂ [@DecidableRel α (· ≤ ·)] (f : ∀ i, κ i → Interval α) :
    ↑(⨅ (i) (j), f i j) = ⋂ (i) (j), (f i j : Set α) 
goal: ↑(⨅ i, ⨅ j, f i j) = ⋂ i, ⋂ j, ↑(f i j)