ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Fin.map_valEmbedding_Ioc
@[simp]
theorem map_valEmbedding_Ioc : (Ioc a b).map Fin.valEmbedding = Ioc ↑a ↑b 
Arguments: {n : ℕ} (a b : Fin n)
Goal: Finset.map Fin.valEmbedding (Finset.Ioc a b) = Finset.Ioc ↑a ↑b
-- Fin.map_valEmbedding_Ioo
@[simp]
theorem map_valEmbedding_Ioo : (Ioo a b).map Fin.valEmbedding = Ioo ↑a ↑b 
Arguments: {n : ℕ} (a b : Fin n)
Goal: Finset.map Fin.valEmbedding (Finset.Ioo a b) = Finset.Ioo ↑a ↑b
-- Fin.map_subtype_embedding_uIcc
@[simp]
theorem map_subtype_embedding_uIcc : (uIcc a b).map valEmbedding = uIcc ↑a ↑b 
Arguments: {n : ℕ} (a b : Fin n)
Goal: Finset.map Fin.valEmbedding (Finset.uIcc a b) = Finset.uIcc ↑a ↑b
-- Fin.card_Icc
@[simp]
theorem card_Icc : (Icc a b).card = b + 1 - a 
Arguments: {n : ℕ} (a b : Fin n)
Goal: (Finset.Icc a b).card = ↑b + 1 - ↑a
-- Fin.card_Ico
@[simp]
theorem card_Ico : (Ico a b).card = b - a 
Arguments: {n : ℕ} (a b : Fin n)
Goal: (Finset.Ico a b).card = ↑b - ↑a
-- Fin.card_Ioc
@[simp]
theorem card_Ioc : (Ioc a b).card = b - a 
Arguments: {n : ℕ} (a b : Fin n)
Goal: (Finset.Ioc a b).card = ↑b - ↑a
-- Fin.card_Ioo
@[simp]
theorem card_Ioo : (Ioo a b).card = b - a - 1 
Arguments: {n : ℕ} (a b : Fin n)
Goal: (Finset.Ioo a b).card = ↑b - ↑a - 1
-- Fin.card_uIcc
@[simp]
theorem card_uIcc : (uIcc a b).card = (b - a : ℤ).natAbs + 1 
Arguments: {n : ℕ} (a b : Fin n)
Goal: (Finset.uIcc a b).card = (↑↑b - ↑↑a).natAbs + 1
-- Fin.card_fintypeIcc
theorem card_fintypeIcc : Fintype.card (Set.Icc a b) = b + 1 - a 
Arguments: {n : ℕ} (a b : Fin n)
Goal: Fintype.card ↑(Set.Icc a b) = ↑b + 1 - ↑a
-- Fin.card_fintypeIco
theorem card_fintypeIco : Fintype.card (Set.Ico a b) = b - a 
Arguments: {n : ℕ} (a b : Fin n)
Goal: Fintype.card ↑(Set.Ico a b) = ↑b - ↑a
-- Fin.card_fintypeIoc
theorem card_fintypeIoc : Fintype.card (Set.Ioc a b) = b - a 
Arguments: {n : ℕ} (a b : Fin n)
Goal: Fintype.card ↑(Set.Ioc a b) = ↑b - ↑a
-- Fin.card_fintypeIoo
theorem card_fintypeIoo : Fintype.card (Set.Ioo a b) = b - a - 1 
Arguments: {n : ℕ} (a b : Fin n)
Goal: Fintype.card ↑(Set.Ioo a b) = ↑b - ↑a - 1
-- Fin.card_fintype_uIcc
theorem card_fintype_uIcc : Fintype.card (Set.uIcc a b) = (b - a : ℤ).natAbs + 1 
Arguments: {n : ℕ} (a b : Fin n)
Goal: Fintype.card ↑(Set.uIcc a b) = (↑↑b - ↑↑a).natAbs + 1
-- Fin.Ici_eq_finset_subtype
theorem Ici_eq_finset_subtype : Ici a = (Icc (a : ℕ) n).fin n 
Arguments: {n : ℕ} (a : Fin n)
Goal: Finset.Ici a = Finset.fin n (Finset.Icc (↑a) n)
-- Fin.Ioi_eq_finset_subtype
theorem Ioi_eq_finset_subtype : Ioi a = (Ioc (a : ℕ) n).fin n 
Arguments: {n : ℕ} (a : Fin n)
Goal: Finset.Ioi a = Finset.fin n (Finset.Ioc (↑a) n)
-- Fin.Iic_eq_finset_subtype
theorem Iic_eq_finset_subtype : Iic b = (Iic (b : ℕ)).fin n 
Arguments: {n : ℕ} (b : Fin n)
Goal: Finset.Iic b = Finset.fin n (Finset.Iic ↑b)
-- Fin.Iio_eq_finset_subtype
theorem Iio_eq_finset_subtype : Iio b = (Iio (b : ℕ)).fin n 
Arguments: {n : ℕ} (b : Fin n)
Goal: Finset.Iio b = Finset.fin n (Finset.Iio ↑b)
-- Fin.map_valEmbedding_Ici
@[simp]
theorem map_valEmbedding_Ici : (Ici a).map Fin.valEmbedding = Icc ↑a (n - 1) 
Arguments: {n : ℕ} (a : Fin n)
Goal: Finset.map Fin.valEmbedding (Finset.Ici a) = Finset.Icc (↑a) (n - 1)
-- Fin.map_valEmbedding_Ioi
@[simp]
theorem map_valEmbedding_Ioi : (Ioi a).map Fin.valEmbedding = Ioc ↑a (n - 1) 
Arguments: {n : ℕ} (a : Fin n)
Goal: Finset.map Fin.valEmbedding (Finset.Ioi a) = Finset.Ioc (↑a) (n - 1)
-- Fin.map_valEmbedding_Iic
@[simp]
theorem map_valEmbedding_Iic : (Iic b).map Fin.valEmbedding = Iic ↑b 
Arguments: {n : ℕ} (b : Fin n)
Goal: Finset.map Fin.valEmbedding (Finset.Iic b) = Finset.Iic ↑b
-- Fin.map_valEmbedding_Iio
@[simp]
theorem map_valEmbedding_Iio : (Iio b).map Fin.valEmbedding = Iio ↑b 
Arguments: {n : ℕ} (b : Fin n)
Goal: Finset.map Fin.valEmbedding (Finset.Iio b) = Finset.Iio ↑b
-- Fin.card_Ici
@[simp]
theorem card_Ici : (Ici a).card = n - a 
Arguments: {n : ℕ} (a : Fin n)
Goal: (Finset.Ici a).card = n - ↑a
-- Fin.card_Ioi
@[simp]
theorem card_Ioi : (Ioi a).card = n - 1 - a 
Arguments: {n : ℕ} (a : Fin n)
Goal: (Finset.Ioi a).card = n - 1 - ↑a
-- Fin.card_Iic
@[simp]
theorem card_Iic : (Iic b).card = b + 1 
Arguments: {n : ℕ} (b : Fin n)
Goal: (Finset.Iic b).card = ↑b + 1
-- Fin.card_Iio
@[simp]
theorem card_Iio : (Iio b).card = b 
Arguments: {n : ℕ} (b : Fin n)
Goal: (Finset.Iio b).card = ↑b
-- Fin.card_fintypeIci
theorem card_fintypeIci : Fintype.card (Set.Ici a) = n - a 
Arguments: {n : ℕ} (a : Fin n)
Goal: Fintype.card ↑(Set.Ici a) = n - ↑a
-- Fin.card_fintypeIoi
theorem card_fintypeIoi : Fintype.card (Set.Ioi a) = n - 1 - a 
Arguments: {n : ℕ} (a : Fin n)
Goal: Fintype.card ↑(Set.Ioi a) = n - 1 - ↑a
-- Fin.card_fintypeIic
theorem card_fintypeIic : Fintype.card (Set.Iic b) = b + 1 
Arguments: {n : ℕ} (b : Fin n)
Goal: Fintype.card ↑(Set.Iic b) = ↑b + 1
-- Fin.card_fintypeIio
theorem card_fintypeIio : Fintype.card (Set.Iio b) = b 
Arguments: {n : ℕ} (b : Fin n)
Goal: Fintype.card ↑(Set.Iio b) = ↑b
-- NonemptyInterval.fst_le_snd
@[ext (flat := false)]
structure NonemptyInterval (α : Type*) [LE α] extends Prod α α where
    fst_le_snd : fst ≤ snd
Arguments: {α : Type u_7} [LE α] (self : NonemptyInterval α)
Goal: self.toProd.1 ≤ self.toProd.2
-- NonemptyInterval.toProd_injective
theorem toProd_injective : Injective (toProd : NonemptyInterval α → α × α) 
Arguments: {α : Type u_1} [LE α]
Goal: Function.Injective NonemptyInterval.toProd
-- NonemptyInterval.toDualProd_apply
@[simp]
theorem toDualProd_apply (s : NonemptyInterval α) : s.toDualProd = (toDual s.fst, s.snd) 
Arguments: {α : Type u_1} [LE α] (s : NonemptyInterval α)
Goal: s.toDualProd = (OrderDual.toDual s.toProd.1, s.toProd.2)
-- NonemptyInterval.toDualProd_injective
theorem toDualProd_injective : Injective (toDualProd : NonemptyInterval α → αᵒᵈ × α) 
Arguments: {α : Type u_1} [LE α]
Goal: Function.Injective NonemptyInterval.toDualProd
-- NonemptyInterval.le_def
theorem le_def : s ≤ t ↔ t.fst ≤ s.fst ∧ s.snd ≤ t.snd 
Arguments: {α : Type u_1} [LE α] {s t : NonemptyInterval α}
Goal: s ≤ t ↔ t.toProd.1 ≤ s.toProd.1 ∧ s.toProd.2 ≤ t.toProd.2
-- NonemptyInterval.toDualProdHom_apply
@[simps]
def toDualProdHom : NonemptyInterval α ↪o αᵒᵈ × α 
Arguments: {α : Type u_1} [LE α]
Goal: ∀ (a : NonemptyInterval α), NonemptyInterval.toDualProdHom a = a.toDualProd
-- NonemptyInterval.fst_dual
@[simp]
theorem fst_dual (s : NonemptyInterval α) : s.dual.fst = toDual s.snd 
Arguments: {α : Type u_1} [LE α] (s : NonemptyInterval α)
Goal: (NonemptyInterval.dual s).toProd.1 = OrderDual.toDual s.toProd.2
-- NonemptyInterval.snd_dual
@[simp]
theorem snd_dual (s : NonemptyInterval α) : s.dual.snd = toDual s.fst 
Arguments: {α : Type u_1} [LE α] (s : NonemptyInterval α)
Goal: (NonemptyInterval.dual s).toProd.2 = OrderDual.toDual s.toProd.1
-- NonemptyInterval.mem_mk
@[simp]
theorem mem_mk {hx : x.1 ≤ x.2} : a ∈ mk x hx ↔ x.1 ≤ a ∧ a ≤ x.2 
Arguments: {α : Type u_1} [Preorder α] {x : α × α} {a : α} {hx : x.1 ≤ x.2}
Goal: a ∈ { toProd := x, fst_le_snd := hx } ↔ x.1 ≤ a ∧ a ≤ x.2
-- NonemptyInterval.mem_def
theorem mem_def : a ∈ s ↔ s.fst ≤ a ∧ a ≤ s.snd 
Arguments: {α : Type u_1} [Preorder α] {s : NonemptyInterval α} {a : α}
Goal: a ∈ s ↔ s.toProd.1 ≤ a ∧ a ≤ s.toProd.2
-- NonemptyInterval.coe_nonempty
theorem coe_nonempty (s : NonemptyInterval α) : (s : Set α).Nonempty 
Arguments: {α : Type u_1} [Preorder α] (s : NonemptyInterval α)
Goal: (Set.Icc s.toProd.1 s.toProd.2).Nonempty
-- NonemptyInterval.pure_snd
@[simps]
def pure (a : α) : NonemptyInterval α 
Arguments: {α : Type u_1} [Preorder α] (a : α)
Goal: (NonemptyInterval.pure a).toProd.2 = a
-- NonemptyInterval.pure_fst
@[simps]
def pure (a : α) : NonemptyInterval α 
Arguments: {α : Type u_1} [Preorder α] (a : α)
Goal: (NonemptyInterval.pure a).toProd.1 = a
-- NonemptyInterval.mem_pure_self
theorem mem_pure_self (a : α) : a ∈ pure a 
Arguments: {α : Type u_1} [Preorder α] (a : α)
Goal: a ∈ NonemptyInterval.pure a
-- NonemptyInterval.pure_injective
theorem pure_injective : Injective (pure : α → NonemptyInterval α) 
Arguments: {α : Type u_1} [Preorder α]
Goal: Function.Injective NonemptyInterval.pure
-- NonemptyInterval.dual_pure
@[simp]
theorem dual_pure (a : α) : dual (pure a) = pure (toDual a) 
Arguments: {α : Type u_1} [Preorder α] (a : α)
Goal: NonemptyInterval.dual (NonemptyInterval.pure a) = NonemptyInterval.pure (OrderDual.toDual a)
-- NonemptyInterval.map_fst
@[simps!]
def map (f : α →o β) (a : NonemptyInterval α) : NonemptyInterval β 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] (f : α →o β) (a : NonemptyInterval α)
Goal: (NonemptyInterval.map f a).toProd.1 = f a.1.1
-- NonemptyInterval.map_snd
@[simps!]
def map (f : α →o β) (a : NonemptyInterval α) : NonemptyInterval β 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] (f : α →o β) (a : NonemptyInterval α)
Goal: (NonemptyInterval.map f a).toProd.2 = f a.1.2
-- NonemptyInterval.map_pure
@[simp]
theorem map_pure (f : α →o β) (a : α) : (pure a).map f = pure (f a) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] (f : α →o β) (a : α)
Goal: NonemptyInterval.map f (NonemptyInterval.pure a) = NonemptyInterval.pure (f a)
-- NonemptyInterval.map_map
@[simp]
theorem map_map (g : β →o γ) (f : α →o β) (a : NonemptyInterval α) :
    (a.map f).map g = a.map (g.comp f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] [Preorder γ] (g : β →o γ) (f : α →o β) (a : NonemptyInterval α)
Goal: NonemptyInterval.map g (NonemptyInterval.map f a) = NonemptyInterval.map (g.comp f) a
-- NonemptyInterval.dual_map
@[simp]
theorem dual_map (f : α →o β) (a : NonemptyInterval α) :
    dual (a.map f) = a.dual.map (OrderHom.dual f) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] (f : α →o β) (a : NonemptyInterval α)
Goal: NonemptyInterval.dual (NonemptyInterval.map f a) = NonemptyInterval.map (OrderHom.dual f) (NonemptyInterval.dual a)
-- NonemptyInterval.map₂_fst
@[simps]
def map₂ (f : α → β → γ) (h₀ : ∀ b, Monotone fun a => f a b) (h₁ : ∀ a, Monotone (f a)) :
    NonemptyInterval α → NonemptyInterval β → NonemptyInterval γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] [Preorder γ] (f : α → β → γ) (h₀ : ∀ (b : β), Monotone fun a => f a b) (h₁ : ∀ (a : α), Monotone (f a))
Goal: ∀ (a : NonemptyInterval α) (a_1 : NonemptyInterval β),
  (NonemptyInterval.map₂ f h₀ h₁ a a_1).toProd.1 = f a.toProd.1 a_1.toProd.1
-- NonemptyInterval.map₂_snd
@[simps]
def map₂ (f : α → β → γ) (h₀ : ∀ b, Monotone fun a => f a b) (h₁ : ∀ a, Monotone (f a)) :
    NonemptyInterval α → NonemptyInterval β → NonemptyInterval γ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] [Preorder γ] (f : α → β → γ) (h₀ : ∀ (b : β), Monotone fun a => f a b) (h₁ : ∀ (a : α), Monotone (f a))
Goal: ∀ (a : NonemptyInterval α) (a_1 : NonemptyInterval β),
  (NonemptyInterval.map₂ f h₀ h₁ a a_1).toProd.2 = f a.toProd.2 a_1.toProd.2
-- NonemptyInterval.map₂_pure
@[simp]
theorem map₂_pure (f : α → β → γ) (h₀ h₁) (a : α) (b : β) :
    map₂ f h₀ h₁ (pure a) (pure b) = pure (f a b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] [Preorder γ] (f : α → β → γ) (h₀ : ∀ (b : β), Monotone fun a => f a b) (h₁ : ∀ (a : α), Monotone (f a)) (a : α) (b : β)
Goal: NonemptyInterval.map₂ f h₀ h₁ (NonemptyInterval.pure a) (NonemptyInterval.pure b) = NonemptyInterval.pure (f a b)
-- NonemptyInterval.dual_map₂
@[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) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] [Preorder γ] (f : α → β → γ) (h₀ : ∀ (b : β), Monotone fun a => f a b) (h₁ : ∀ (a : α), Monotone (f a)) (s : NonemptyInterval α) (t : NonemptyInterval β)
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)
-- NonemptyInterval.dual_top
@[simp]
theorem dual_top : dual (⊤ : NonemptyInterval α) = ⊤ 
Arguments: {α : Type u_1} [Preorder α] [BoundedOrder α]
Goal: NonemptyInterval.dual ⊤ = ⊤
-- NonemptyInterval.coe_subset_coe
@[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_subset_coe : (s : Set α) ⊆ t ↔ (s : NonemptyInterval α) ≤ t 
Arguments: {α : Type u_1} [PartialOrder α] {s t : NonemptyInterval α}
Goal: ↑s ⊆ ↑t ↔ s ≤ t
-- NonemptyInterval.coe_ssubset_coe
@[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_ssubset_coe : (s : Set α) ⊂ t ↔ s < t 
Arguments: {α : Type u_1} [PartialOrder α] {s t : NonemptyInterval α}
Goal: ↑s ⊂ ↑t ↔ s < t
-- NonemptyInterval.coe_coeHom
@[simp]
theorem coe_coeHom : (coeHom : NonemptyInterval α → Set α) = ((↑) : NonemptyInterval α → Set α) 
Arguments: {α : Type u_1} [PartialOrder α]
Goal: ⇑NonemptyInterval.coeHom = SetLike.coe
-- NonemptyInterval.coe_def
theorem coe_def (s : NonemptyInterval α) : (s : Set α) = Set.Icc s.toProd.1 s.toProd.2 
Arguments: {α : Type u_1} [PartialOrder α] (s : NonemptyInterval α)
Goal: ↑s = Set.Icc s.toProd.1 s.toProd.2
-- NonemptyInterval.coe_pure
@[simp, norm_cast]
theorem coe_pure (a : α) : (pure a : Set α) = {a} 
Arguments: {α : Type u_1} [PartialOrder α] (a : α)
Goal: ↑(NonemptyInterval.pure a) = {a}
-- NonemptyInterval.mem_pure
@[simp]
theorem mem_pure : b ∈ pure a ↔ b = a 
Arguments: {α : Type u_1} [PartialOrder α] {a b : α}
Goal: b ∈ NonemptyInterval.pure a ↔ b = a
-- NonemptyInterval.coe_top
@[simp, norm_cast]
theorem coe_top [BoundedOrder α] : ((⊤ : NonemptyInterval α) : Set α) = univ 
Arguments: {α : Type u_1} [PartialOrder α] [BoundedOrder α]
Goal: ↑⊤ = Set.univ
-- NonemptyInterval.coe_dual
@[simp, norm_cast]
theorem coe_dual (s : NonemptyInterval α) : (dual s : Set αᵒᵈ) = ofDual ⁻¹' s 
Arguments: {α : Type u_1} [PartialOrder α] (s : NonemptyInterval α)
Goal: ↑(NonemptyInterval.dual s) = ⇑OrderDual.ofDual ⁻¹' ↑s
-- NonemptyInterval.subset_coe_map
theorem subset_coe_map (f : α →o β) (s : NonemptyInterval α) : f '' s ⊆ s.map f 
Arguments: {α : Type u_1} {β : Type u_2} [PartialOrder α] [PartialOrder β] (f : α →o β) (s : NonemptyInterval α)
Goal: ⇑f '' ↑s ⊆ ↑(NonemptyInterval.map f s)
-- NonemptyInterval.fst_sup
@[simp]
theorem fst_sup (s t : NonemptyInterval α) : (s ⊔ t).fst = s.fst ⊓ t.fst 
Arguments: {α : Type u_1} [Lattice α] (s t : NonemptyInterval α)
Goal: (s ⊔ t).toProd.1 = s.toProd.1 ⊓ t.toProd.1
-- NonemptyInterval.snd_sup
@[simp]
theorem snd_sup (s t : NonemptyInterval α) : (s ⊔ t).snd = s.snd ⊔ t.snd 
Arguments: {α : Type u_1} [Lattice α] (s t : NonemptyInterval α)
Goal: (s ⊔ t).toProd.2 = s.toProd.2 ⊔ t.toProd.2
-- Interval.coe_injective
theorem coe_injective : Injective ((↑) : NonemptyInterval α → Interval α) 
Arguments: {α : Type u_1} [LE α]
Goal: Function.Injective WithBot.some
-- Interval.coe_inj
@[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_inj {s t : NonemptyInterval α} : (s : Interval α) = t ↔ s = t 
Arguments: {α : Type u_1} [LE α] {s t : NonemptyInterval α}
Goal: ↑s = ↑t ↔ s = t
-- Interval.forall
protected
theorem «forall» {p : Interval α → Prop} : (∀ s, p s) ↔ p ⊥ ∧ ∀ s : NonemptyInterval α, p s 
Arguments: {α : Type u_1} [LE α] {p : Interval α → Prop}
Goal: (∀ (s : Interval α), p s) ↔ p ⊥ ∧ ∀ (s : NonemptyInterval α), p ↑s
-- Interval.exists
protected
theorem «exists» {p : Interval α → Prop} : (∃ s, p s) ↔ p ⊥ ∨ ∃ s : NonemptyInterval α, p s 
Arguments: {α : Type u_1} [LE α] {p : Interval α → Prop}
Goal: (∃ s, p s) ↔ p ⊥ ∨ ∃ s, p ↑s
-- Interval.pure_injective
theorem pure_injective : Injective (pure : α → Interval α) 
Arguments: {α : Type u_1} [Preorder α]
Goal: Function.Injective Interval.pure
-- Interval.dual_pure
@[simp]
theorem dual_pure (a : α) : dual (pure a) = pure (toDual a) 
Arguments: {α : Type u_1} [Preorder α] (a : α)
Goal: Interval.dual (Interval.pure a) = Interval.pure (OrderDual.toDual a)
-- Interval.dual_bot
@[simp]
theorem dual_bot : dual (⊥ : Interval α) = ⊥ 
Arguments: {α : Type u_1} [Preorder α]
Goal: Interval.dual ⊥ = ⊥
-- Interval.pure_ne_bot
@[simp]
theorem pure_ne_bot {a : α} : pure a ≠ ⊥ 
Arguments: {α : Type u_1} [Preorder α] {a : α}
Goal: Interval.pure a ≠ ⊥
-- Interval.bot_ne_pure
@[simp]
theorem bot_ne_pure {a : α} : ⊥ ≠ pure a 
Arguments: {α : Type u_1} [Preorder α] {a : α}
Goal: ⊥ ≠ Interval.pure a
-- Interval.map_pure
@[simp]
theorem map_pure (f : α →o β) (a : α) : (pure a).map f = pure (f a) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] (f : α →o β) (a : α)
Goal: Interval.map f (Interval.pure a) = Interval.pure (f a)
-- Interval.map_map
@[simp]
theorem map_map (g : β →o γ) (f : α →o β) (s : Interval α) : (s.map f).map g = s.map (g.comp f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] [Preorder β] [Preorder γ] (g : β →o γ) (f : α →o β) (s : Interval α)
Goal: Interval.map g (Interval.map f s) = Interval.map (g.comp f) s
-- Interval.dual_map
@[simp]
theorem dual_map (f : α →o β) (s : Interval α) : dual (s.map f) = s.dual.map (OrderHom.dual f) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] (f : α →o β) (s : Interval α)
Goal: Interval.dual (Interval.map f s) = Interval.map (OrderHom.dual f) (Interval.dual s)
-- Interval.dual_top
@[simp]
theorem dual_top : dual (⊤ : Interval α) = ⊤ 
Arguments: {α : Type u_1} [Preorder α] [BoundedOrder α]
Goal: Interval.dual ⊤ = ⊤
-- Interval.coe_subset_coe
@[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_subset_coe : (s : Set α) ⊆ t ↔ s ≤ t 
Arguments: {α : Type u_1} [PartialOrder α] {s t : Interval α}
Goal: ↑s ⊆ ↑t ↔ s ≤ t
-- Interval.coe_sSubset_coe
@[norm_cast] -- @[simp, norm_cast] -- Porting note: not in simpNF
theorem coe_sSubset_coe : (s : Set α) ⊂ t ↔ s < t 
Arguments: {α : Type u_1} [PartialOrder α] {s t : Interval α}
Goal: ↑s ⊂ ↑t ↔ s < t
-- Interval.coe_pure
@[simp, norm_cast]
theorem coe_pure (a : α) : (pure a : Set α) = {a} 
Arguments: {α : Type u_1} [PartialOrder α] (a : α)
Goal: ↑(Interval.pure a) = {a}
-- Interval.coe_coe
@[simp, norm_cast]
theorem coe_coe (s : NonemptyInterval α) : ((s : Interval α) : Set α) = s 
Arguments: {α : Type u_1} [PartialOrder α] (s : NonemptyInterval α)
Goal: ↑↑s = ↑s
-- Interval.coe_bot
@[simp, norm_cast]
theorem coe_bot : ((⊥ : Interval α) : Set α) = ∅ 
Arguments: {α : Type u_1} [PartialOrder α]
Goal: ↑⊥ = ∅
-- Interval.coe_top
@[simp, norm_cast]
theorem coe_top [BoundedOrder α] : ((⊤ : Interval α) : Set α) = univ 
Arguments: {α : Type u_1} [PartialOrder α] [BoundedOrder α]
Goal: ↑⊤ = Set.univ
-- Interval.coe_dual
@[simp, norm_cast]
theorem coe_dual (s : Interval α) : (dual s : Set αᵒᵈ) = ofDual ⁻¹' s 
Arguments: {α : Type u_1} [PartialOrder α] (s : Interval α)
Goal: ↑(Interval.dual s) = ⇑OrderDual.ofDual ⁻¹' ↑s
-- Interval.subset_coe_map
theorem subset_coe_map (f : α →o β) : ∀ s : Interval α, f '' s ⊆ s.map f
  
Arguments: {α : Type u_1} {β : Type u_2} [PartialOrder α] [PartialOrder β] (f : α →o β) (s : Interval α)
Goal: ⇑f '' ↑s ⊆ ↑(Interval.map f s)
-- Interval.mem_pure
@[simp]
theorem mem_pure : b ∈ pure a ↔ b = a 
Arguments: {α : Type u_1} [PartialOrder α] {a b : α}
Goal: b ∈ Interval.pure a ↔ b = a
-- Interval.mem_pure_self
theorem mem_pure_self (a : α) : a ∈ pure a 
Arguments: {α : Type u_1} [PartialOrder α] (a : α)
Goal: a ∈ Interval.pure a
-- Interval.coe_inf
@[simp, norm_cast]
theorem coe_inf : ∀ s t : Interval α, (↑(s ⊓ t) : Set α) = ↑s ∩ ↑t
  
Arguments: {α : Type u_1} [Lattice α] [DecidableRel fun x x_1 => x ≤ x_1] (s t : Interval α)
Goal: ↑(s ⊓ t) = ↑s ∩ ↑t
-- Interval.disjoint_coe
@[simp, norm_cast]
theorem disjoint_coe (s t : Interval α) : Disjoint (s : Set α) t ↔ Disjoint s t 
Arguments: {α : Type u_1} [Lattice α] (s t : Interval α)
Goal: Disjoint ↑s ↑t ↔ Disjoint s t
-- NonemptyInterval.coe_pure_interval
@[simp, norm_cast]
theorem coe_pure_interval (a : α) : (pure a : Interval α) = Interval.pure a 
Arguments: {α : Type u_1} [Preorder α] (a : α)
Goal: ↑(NonemptyInterval.pure a) = Interval.pure a
-- NonemptyInterval.coe_eq_pure
@[simp, norm_cast]
theorem coe_eq_pure : (s : Interval α) = Interval.pure a ↔ s = pure a 
Arguments: {α : Type u_1} [Preorder α] {s : NonemptyInterval α} {a : α}
Goal: ↑s = Interval.pure a ↔ s = NonemptyInterval.pure a
-- NonemptyInterval.coe_top_interval
@[simp, norm_cast]
theorem coe_top_interval [BoundedOrder α] : ((⊤ : NonemptyInterval α) : Interval α) = ⊤ 
Arguments: {α : Type u_1} [Preorder α] [BoundedOrder α]
Goal: ↑⊤ = ⊤
-- NonemptyInterval.mem_coe_interval
@[simp, norm_cast]
theorem mem_coe_interval [PartialOrder α] {s : NonemptyInterval α} {x : α} :
    x ∈ (s : Interval α) ↔ x ∈ s 
Arguments: {α : Type u_1} [PartialOrder α] {s : NonemptyInterval α} {x : α}
Goal: x ∈ ↑s ↔ x ∈ s
-- NonemptyInterval.coe_sup_interval
@[simp, norm_cast]
theorem coe_sup_interval [Lattice α] (s t : NonemptyInterval α) :
    (↑(s ⊔ t) : Interval α) = ↑s ⊔ ↑t 
Arguments: {α : Type u_1} [Lattice α] (s t : NonemptyInterval α)
Goal: ↑(s ⊔ t) = ↑s ⊔ ↑t
-- Interval.coe_sInf
@[simp, norm_cast]
theorem coe_sInf [@DecidableRel α (· ≤ ·)] (S : Set (Interval α)) :
    ↑(sInf S) = ⋂ s ∈ S, (s : Set α) 
Arguments: {α : Type u_1} [CompleteLattice α] [DecidableRel fun x x_1 => x ≤ x_1] (S : Set (Interval α))
Goal: ↑(sInf S) = ⋂ s ∈ S, ↑s
-- Interval.coe_iInf
@[simp, norm_cast]
theorem coe_iInf [@DecidableRel α (· ≤ ·)] (f : ι → Interval α) :
    ↑(⨅ i, f i) = ⋂ i, (f i : Set α) 
Arguments: {α : Type u_1} {ι : Sort u_5} [CompleteLattice α] [DecidableRel fun x x_1 => x ≤ x_1] (f : ι → Interval α)
Goal: ↑(⨅ i, f i) = ⋂ i, ↑(f i)
-- Interval.coe_iInf₂
@[norm_cast]
theorem coe_iInf₂ [@DecidableRel α (· ≤ ·)] (f : ∀ i, κ i → Interval α) :
    ↑(⨅ (i) (j), f i j) = ⋂ (i) (j), (f i j : Set α) 
Arguments: {α : Type u_1} {ι : Sort u_5} {κ : ι → Sort u_6} [CompleteLattice α] [DecidableRel fun x x_1 => x ≤ x_1] (f : (i : ι) → κ i → Interval α)
Goal: ↑(⨅ i, ⨅ j, f i j) = ⋂ i, ⋂ j, ↑(f i j)
-- antisymmRel_swap
theorem antisymmRel_swap : AntisymmRel (swap r) = AntisymmRel r 
Arguments: {α : Type u_1} (r : α → α → Prop)
Goal: AntisymmRel (Function.swap r) = AntisymmRel r
-- antisymmRel_refl
@[refl]
theorem antisymmRel_refl [IsRefl α r] (a : α) : AntisymmRel r a a 
Arguments: {α : Type u_1} (r : α → α → Prop) [IsRefl α r] (a : α)
Goal: AntisymmRel r a a
-- AntisymmRel.symm
@[symm]
theorem AntisymmRel.symm {a b : α} : AntisymmRel r a b → AntisymmRel r b a 
Arguments: {α : Type u_1} {r : α → α → Prop} {a b : α}
Goal: AntisymmRel r a b → AntisymmRel r b a
-- AntisymmRel.trans
@[trans]
theorem AntisymmRel.trans [IsTrans α r] {a b c : α} (hab : AntisymmRel r a b)
    (hbc : AntisymmRel r b c) : AntisymmRel r a c 
Arguments: {α : Type u_1} {r : α → α → Prop} [IsTrans α r] {a b c : α} (hab : AntisymmRel r a b) (hbc : AntisymmRel r b c)
Goal: AntisymmRel r a c
-- antisymmRel_iff_eq
@[simp]
theorem antisymmRel_iff_eq [IsRefl α r] [IsAntisymm α r] {a b : α} : AntisymmRel r a b ↔ a = b 
Arguments: {α : Type u_1} {r : α → α → Prop} [IsRefl α r] [IsAntisymm α r] {a b : α}
Goal: AntisymmRel r a b ↔ a = b
-- AntisymmRel.setoid_r
@[simps]
def AntisymmRel.setoid : Setoid α 
Arguments: (α : Type u_1) (r : α → α → Prop) [IsPreorder α r] (a b : α)
Goal: Setoid.r a b = AntisymmRel r a b
-- Antisymmetrization.ind
@[elab_as_elim]
protected theorem Antisymmetrization.ind {p : Antisymmetrization α r → Prop} :
    (∀ a, p <| toAntisymmetrization r a) → ∀ q, p q 
Arguments: {α : Type u_1} (r : α → α → Prop) [IsPreorder α r] {p : Antisymmetrization α r → Prop}
Goal: (∀ (a : α), p (toAntisymmetrization r a)) → ∀ (q : Antisymmetrization α r), p q
-- Antisymmetrization.induction_on
@[elab_as_elim]
protected theorem Antisymmetrization.induction_on {p : Antisymmetrization α r → Prop}
    (a : Antisymmetrization α r) (h : ∀ a, p <| toAntisymmetrization r a) : p a 
Arguments: {α : Type u_1} (r : α → α → Prop) [IsPreorder α r] {p : Antisymmetrization α r → Prop} (a : Antisymmetrization α r) (h : ∀ (a : α), p (toAntisymmetrization r a))
Goal: p a
-- toAntisymmetrization_ofAntisymmetrization
@[simp]
theorem toAntisymmetrization_ofAntisymmetrization (a : Antisymmetrization α r) :
    toAntisymmetrization r (ofAntisymmetrization r a) = a 
Arguments: {α : Type u_1} (r : α → α → Prop) [IsPreorder α r] (a : Antisymmetrization α r)
Goal: toAntisymmetrization r (ofAntisymmetrization r a) = a