ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- FinPartOrd.Iso.mk_hom
@[simps]
def Iso.mk {α β : FinPartOrd.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : FinPartOrd} (e : ↑α.toPartOrd ≃o ↑β.toPartOrd)
Goal: (FinPartOrd.Iso.mk e).hom = ↑e
-- FinPartOrd.dual_obj
@[simps]
def dual : FinPartOrd ⥤ FinPartOrd 
Arguments: (X : FinPartOrd)
Goal: FinPartOrd.dual.obj X = FinPartOrd.of (↑X.toPartOrd)ᵒᵈ
-- FinPartOrd.dual_map
@[simps]
def dual : FinPartOrd ⥤ FinPartOrd 
Arguments: {X Y : FinPartOrd} (a : ↑X.toPartOrd →o ↑Y.toPartOrd)
Goal: FinPartOrd.dual.map a = OrderHom.dual a
-- FinPartOrd.dualEquiv_functor
@[simps! functor inverse]
def dualEquiv : FinPartOrd ≌ FinPartOrd 
Goal: FinPartOrd.dualEquiv.functor = FinPartOrd.dual
-- FinPartOrd.dualEquiv_inverse
@[simps! functor inverse]
def dualEquiv : FinPartOrd ≌ FinPartOrd 
Goal: FinPartOrd.dualEquiv.inverse = FinPartOrd.dual
-- FinPartOrd_dual_comp_forget_to_partOrd
theorem FinPartOrd_dual_comp_forget_to_partOrd :
    FinPartOrd.dual ⋙ forget₂ FinPartOrd PartOrd =
      forget₂ FinPartOrd PartOrd ⋙ PartOrd.dual 
Goal: FinPartOrd.dual ⋙ CategoryTheory.forget₂ FinPartOrd PartOrd = CategoryTheory.forget₂ FinPartOrd PartOrd ⋙ PartOrd.dual
-- Lat.coe_of
@[simp]
theorem coe_of (α : Type*) [Lattice α] : ↥(of α) = α 
Arguments: (α : Type u_1) [Lattice α]
Goal: ↑(Lat.of α) = α
-- Lat.Iso.mk_hom_toSupHom_toFun
@[simps]
def Iso.mk {α β : Lat.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : Lat} (e : ↑α ≃o ↑β) (a : ↑α)
Goal: (Lat.Iso.mk e).hom.toSupHom a = e a
-- Lat.Iso.mk_inv_toSupHom_toFun
@[simps]
def Iso.mk {α β : Lat.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : Lat} (e : ↑α ≃o ↑β) (a : ↑β)
Goal: (Lat.Iso.mk e).inv.toSupHom a = e.symm a
-- Lat.dual_obj
@[simps]
def dual : Lat ⥤ Lat 
Arguments: (X : Lat)
Goal: Lat.dual.obj X = Lat.of (↑X)ᵒᵈ
-- Lat.dual_map
@[simps]
def dual : Lat ⥤ Lat 
Goal: ∀ {X Y : Lat} (a : LatticeHom ↑X ↑Y), Lat.dual.map a = LatticeHom.dual a
-- Lat.dualEquiv_functor
@[simps functor inverse]
def dualEquiv : Lat ≌ Lat 
Goal: Lat.dualEquiv.functor = Lat.dual
-- Lat.dualEquiv_inverse
@[simps functor inverse]
def dualEquiv : Lat ≌ Lat 
Goal: Lat.dualEquiv.inverse = Lat.dual
-- Lat_dual_comp_forget_to_partOrd
theorem Lat_dual_comp_forget_to_partOrd :
    Lat.dual ⋙ forget₂ Lat PartOrd = forget₂ Lat PartOrd ⋙ PartOrd.dual 
Goal: Lat.dual ⋙ CategoryTheory.forget₂ Lat PartOrd = CategoryTheory.forget₂ Lat PartOrd ⋙ PartOrd.dual
-- LinOrd.coe_of
@[simp]
theorem coe_of (α : Type*) [LinearOrder α] : ↥(of α) = α 
Arguments: (α : Type u_1) [LinearOrder α]
Goal: ↑(LinOrd.of α) = α
-- LinOrd.Iso.mk_inv
@[simps]
def Iso.mk {α β : LinOrd.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : LinOrd} (e : ↑α ≃o ↑β)
Goal: (LinOrd.Iso.mk e).inv = ↑e.symm
-- LinOrd.Iso.mk_hom
@[simps]
def Iso.mk {α β : LinOrd.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : LinOrd} (e : ↑α ≃o ↑β)
Goal: (LinOrd.Iso.mk e).hom = ↑e
-- LinOrd.dual_map
@[simps]
def dual : LinOrd ⥤ LinOrd 
Goal: ∀ {X Y : LinOrd} (a : ↑X →o ↑Y), LinOrd.dual.map a = OrderHom.dual a
-- LinOrd.dual_obj
@[simps]
def dual : LinOrd ⥤ LinOrd 
Arguments: (X : LinOrd)
Goal: LinOrd.dual.obj X = LinOrd.of (↑X)ᵒᵈ
-- LinOrd.dualEquiv_inverse
@[simps functor inverse]
def dualEquiv : LinOrd ≌ LinOrd 
Goal: LinOrd.dualEquiv.inverse = LinOrd.dual
-- LinOrd.dualEquiv_functor
@[simps functor inverse]
def dualEquiv : LinOrd ≌ LinOrd 
Goal: LinOrd.dualEquiv.functor = LinOrd.dual
-- linOrd_dual_comp_forget_to_Lat
theorem linOrd_dual_comp_forget_to_Lat :
    LinOrd.dual ⋙ forget₂ LinOrd Lat = forget₂ LinOrd Lat ⋙ Lat.dual 
Goal: LinOrd.dual ⋙ CategoryTheory.forget₂ LinOrd Lat = CategoryTheory.forget₂ LinOrd Lat ⋙ Lat.dual
-- WellFounded.isAsymm
protected theorem isAsymm (h : WellFounded r) : IsAsymm α r 
Arguments: {α : Type u_1} {r : α → α → Prop} (h : WellFounded r)
Goal: IsAsymm α r
-- WellFounded.isIrrefl
protected theorem isIrrefl (h : WellFounded r) : IsIrrefl α r 
Arguments: {α : Type u_1} {r : α → α → Prop} (h : WellFounded r)
Goal: IsIrrefl α r
-- WellFounded.mono
theorem mono (hr : WellFounded r) (h : ∀ a b, r' a b → r a b) : WellFounded r' 
Arguments: {α : Type u_1} {r r' : α → α → Prop} (hr : WellFounded r) (h : ∀ (a b : α), r' a b → r a b)
Goal: WellFounded r'
-- WellFounded.onFun
theorem onFun {α β : Sort*} {r : β → β → Prop} {f : α → β} :
    WellFounded r → WellFounded (r on f) 
Arguments: {α : Sort u_4} {β : Sort u_5} {r : β → β → Prop} {f : α → β}
Goal: WellFounded r → WellFounded (r on f)
-- WellFounded.has_min
theorem has_min {α} {r : α → α → Prop} (H : WellFounded r) (s : Set α) :
    s.Nonempty → ∃ a ∈ s, ∀ x ∈ s, ¬r x a
  
Arguments: {α : Type u_4} {r : α → α → Prop} (H : WellFounded r) (s : Set α)
Goal: s.Nonempty → ∃ a ∈ s, ∀ x ∈ s, ¬r x a
-- WellFounded.min_mem
theorem min_mem {r : α → α → Prop} (H : WellFounded r) (s : Set α) (h : s.Nonempty) :
    H.min s h ∈ s 
Arguments: {α : Type u_1} {r : α → α → Prop} (H : WellFounded r) (s : Set α) (h : s.Nonempty)
Goal: H.min s h ∈ s
-- WellFounded.not_lt_min
theorem not_lt_min {r : α → α → Prop} (H : WellFounded r) (s : Set α) (h : s.Nonempty) {x}
    (hx : x ∈ s) : ¬r x (H.min s h) 
Arguments: {α : Type u_1} {r : α → α → Prop} (H : WellFounded r) (s : Set α) (h : s.Nonempty) {x : α} (hx : x ∈ s)
Goal: ¬r x (H.min s h)
-- WellFounded.wellFounded_iff_has_min
theorem wellFounded_iff_has_min {r : α → α → Prop} :
    WellFounded r ↔ ∀ s : Set α, s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m 
Arguments: {α : Type u_1} {r : α → α → Prop}
Goal: WellFounded r ↔ ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m
-- WellFounded.lt_sup
protected theorem lt_sup {r : α → α → Prop} (wf : WellFounded r) {s : Set α} (h : Bounded r s) {x}
    (hx : x ∈ s) : r x (wf.sup s h) 
Arguments: {α : Type u_1} {r : α → α → Prop} (wf : WellFounded r) {s : Set α} (h : Set.Bounded r s) {x : α} (hx : x ∈ s)
Goal: r x (wf.sup s h)
-- WellFounded.lt_succ
protected theorem lt_succ {r : α → α → Prop} (wf : WellFounded r) {x : α} (h : ∃ y, r x y) :
    r x (wf.succ x) 
Arguments: {α : Type u_1} {r : α → α → Prop} (wf : WellFounded r) {x : α} (h : ∃ y, r x y)
Goal: r x (wf.succ x)
-- WellFounded.lt_succ_iff
protected theorem lt_succ_iff {r : α → α → Prop} [wo : IsWellOrder α r] {x : α} (h : ∃ y, r x y)
    (y : α) : r y (wo.wf.succ x) ↔ r y x ∨ y = x 
Arguments: {α : Type u_1} {r : α → α → Prop} [wo : IsWellOrder α r] {x : α} (h : ∃ y, r x y) (y : α)
Goal: r y (⋯.succ x) ↔ r y x ∨ y = x
-- WellFounded.min_le
theorem min_le (h : WellFounded ((· < ·) : β → β → Prop)) {x : β} {s : Set β} (hx : x ∈ s)
    (hne : s.Nonempty := ⟨x, hx⟩) : h.min s hne ≤ x 
Arguments: {β : Type u_2} [LinearOrder β] (h : WellFounded fun x x_1 => x < x_1) {x : β} {s : Set β} (hx : x ∈ s) (hne : s.Nonempty := ⋯)
Goal: h.min s hne ≤ x
-- _private.Mathlib.Order.WellFounded.0.WellFounded.eq_strictMono_iff_eq_range_aux
private theorem eq_strictMono_iff_eq_range_aux {f g : β → γ} (hf : StrictMono f)
    (hg : StrictMono g) (hfg : Set.range f = Set.range g) {b : β} (H : ∀ a < b, f a = g a) :
    f b ≤ g b 
Arguments: {β : Type u_2} {γ : Type u_3} [LinearOrder β] [PartialOrder γ] {f g : β → γ} (hf : StrictMono f) (hg : StrictMono g) (hfg : Set.range f = Set.range g) {b : β} (H : ∀ a < b, f a = g a)
Goal: f b ≤ g b
-- WellFounded.eq_strictMono_iff_eq_range
theorem eq_strictMono_iff_eq_range (h : WellFounded ((· < ·) : β → β → Prop)) {f g : β → γ}
    (hf : StrictMono f) (hg : StrictMono g) :
    Set.range f = Set.range g ↔ f = g 
Arguments: {β : Type u_2} {γ : Type u_3} [LinearOrder β] [PartialOrder γ] (h : WellFounded fun x x_1 => x < x_1) {f g : β → γ} (hf : StrictMono f) (hg : StrictMono g)
Goal: Set.range f = Set.range g ↔ f = g
-- WellFounded.self_le_of_strictMono
theorem self_le_of_strictMono (h : WellFounded ((· < ·) : β → β → Prop)) {f : β → β}
    (hf : StrictMono f) : ∀ n, n ≤ f n 
Arguments: {β : Type u_2} [LinearOrder β] (h : WellFounded fun x x_1 => x < x_1) {f : β → β} (hf : StrictMono f) (n : β)
Goal: n ≤ f n
-- Function.not_lt_argmin
theorem not_lt_argmin [Nonempty α] (a : α) : ¬f a < f (argmin f h) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) [LT β] (h : WellFounded fun x x_1 => x < x_1) [Nonempty α] (a : α)
Goal: ¬f a < f (Function.argmin f h)
-- Function.argminOn_mem
@[simp]
theorem argminOn_mem (s : Set α) (hs : s.Nonempty) : argminOn f h s hs ∈ s 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) [LT β] (h : WellFounded fun x x_1 => x < x_1) (s : Set α) (hs : s.Nonempty)
Goal: Function.argminOn f h s hs ∈ s
-- Function.not_lt_argminOn
theorem not_lt_argminOn (s : Set α) {a : α} (ha : a ∈ s)
    (hs : s.Nonempty := Set.nonempty_of_mem ha) : ¬f a < f (argminOn f h s hs) 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) [LT β] (h : WellFounded fun x x_1 => x < x_1) (s : Set α) {a : α} (ha : a ∈ s) (hs : s.Nonempty := ⋯)
Goal: ¬f a < f (Function.argminOn f h s hs)
-- Function.argmin_le
theorem argmin_le (a : α) [Nonempty α] : f (argmin f h) ≤ f a 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) [LinearOrder β] (h : WellFounded fun x x_1 => x < x_1) (a : α) [Nonempty α]
Goal: f (Function.argmin f h) ≤ f a
-- Function.argminOn_le
theorem argminOn_le (s : Set α) {a : α} (ha : a ∈ s) (hs : s.Nonempty := Set.nonempty_of_mem ha) :
    f (argminOn f h s hs) ≤ f a 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) [LinearOrder β] (h : WellFounded fun x x_1 => x < x_1) (s : Set α) {a : α} (ha : a ∈ s) (hs : s.Nonempty := ⋯)
Goal: f (Function.argminOn f h s hs) ≤ f a
-- Acc.induction_bot'
theorem Acc.induction_bot' {α β} {r : α → α → Prop} {a bot : α} (ha : Acc r a) {C : β → Prop}
    {f : α → β} (ih : ∀ b, f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c)) : C (f a) → C (f bot) 
Arguments: {α : Sort u_4} {β : Sort u_5} {r : α → α → Prop} {a bot : α} (ha : Acc r a) {C : β → Prop} {f : α → β} (ih : ∀ (b : α), f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c))
Goal: C (f a) → C (f bot)
-- Acc.induction_bot
theorem Acc.induction_bot {α} {r : α → α → Prop} {a bot : α} (ha : Acc r a) {C : α → Prop}
    (ih : ∀ b, b ≠ bot → C b → ∃ c, r c b ∧ C c) : C a → C bot 
Arguments: {α : Sort u_4} {r : α → α → Prop} {a bot : α} (ha : Acc r a) {C : α → Prop} (ih : ∀ (b : α), b ≠ bot → C b → ∃ c, r c b ∧ C c)
Goal: C a → C bot
-- WellFounded.induction_bot'
theorem WellFounded.induction_bot' {α β} {r : α → α → Prop} (hwf : WellFounded r) {a bot : α}
    {C : β → Prop} {f : α → β} (ih : ∀ b, f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c)) :
    C (f a) → C (f bot) 
Arguments: {α : Sort u_4} {β : Sort u_5} {r : α → α → Prop} (hwf : WellFounded r) {a bot : α} {C : β → Prop} {f : α → β} (ih : ∀ (b : α), f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c))
Goal: C (f a) → C (f bot)
-- WellFounded.induction_bot
theorem WellFounded.induction_bot {α} {r : α → α → Prop} (hwf : WellFounded r) {a bot : α}
    {C : α → Prop} (ih : ∀ b, b ≠ bot → C b → ∃ c, r c b ∧ C c) : C a → C bot 
Arguments: {α : Sort u_4} {r : α → α → Prop} (hwf : WellFounded r) {a bot : α} {C : α → Prop} (ih : ∀ (b : α), b ≠ bot → C b → ∃ c, r c b ∧ C c)
Goal: C a → C bot
-- StrictMono.wellFoundedLT
theorem StrictMono.wellFoundedLT [WellFoundedLT β] (hf : StrictMono f) : WellFoundedLT α 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β} [WellFoundedLT β] (hf : StrictMono f)
Goal: WellFoundedLT α
-- StrictAnti.wellFoundedLT
theorem StrictAnti.wellFoundedLT [WellFoundedGT β] (hf : StrictAnti f) : WellFoundedLT α 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β} [WellFoundedGT β] (hf : StrictAnti f)
Goal: WellFoundedLT α
-- StrictMono.wellFoundedGT
theorem StrictMono.wellFoundedGT [WellFoundedGT β] (hf : StrictMono f) : WellFoundedGT α 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β} [WellFoundedGT β] (hf : StrictMono f)
Goal: WellFoundedGT α
-- StrictAnti.wellFoundedGT
theorem StrictAnti.wellFoundedGT [WellFoundedLT β] (hf : StrictAnti f) : WellFoundedGT α 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] {f : α → β} [WellFoundedLT β] (hf : StrictAnti f)
Goal: WellFoundedGT α
-- DistLat.coe_of
@[simp]
theorem coe_of (α : Type*) [DistribLattice α] : ↥(of α) = α 
Arguments: (α : Type u_1) [DistribLattice α]
Goal: ↑(DistLat.of α) = α
-- DistLat.Iso.mk_hom_toSupHom_toFun
@[simps]
def Iso.mk {α β : DistLat.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : DistLat} (e : ↑α ≃o ↑β) (a : ↑α)
Goal: (DistLat.Iso.mk e).hom.toSupHom a = e a
-- DistLat.Iso.mk_inv_toSupHom_toFun
@[simps]
def Iso.mk {α β : DistLat.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : DistLat} (e : ↑α ≃o ↑β) (a : ↑β)
Goal: (DistLat.Iso.mk e).inv.toSupHom a = e.symm a
-- DistLat.dual_map
@[simps]
def dual : DistLat ⥤ DistLat 
Goal: ∀ {X Y : DistLat} (a : LatticeHom ↑X ↑Y), DistLat.dual.map a = LatticeHom.dual a
-- DistLat.dual_obj
@[simps]
def dual : DistLat ⥤ DistLat 
Arguments: (X : DistLat)
Goal: DistLat.dual.obj X = DistLat.of (↑X)ᵒᵈ
-- DistLat.dualEquiv_functor
@[simps functor inverse]
def dualEquiv : DistLat ≌ DistLat 
Goal: DistLat.dualEquiv.functor = DistLat.dual
-- DistLat.dualEquiv_inverse
@[simps functor inverse]
def dualEquiv : DistLat ≌ DistLat 
Goal: DistLat.dualEquiv.inverse = DistLat.dual
-- distLat_dual_comp_forget_to_Lat
theorem distLat_dual_comp_forget_to_Lat :
    DistLat.dual ⋙ forget₂ DistLat Lat = forget₂ DistLat Lat ⋙ Lat.dual 
Goal: DistLat.dual ⋙ CategoryTheory.forget₂ DistLat Lat = CategoryTheory.forget₂ DistLat Lat ⋙ Lat.dual
-- Filter.mem_atTop
theorem mem_atTop [Preorder α] (a : α) : { b : α | a ≤ b } ∈ @atTop α _ 
Arguments: {α : Type u_3} [Preorder α] (a : α)
Goal: {b | a ≤ b} ∈ Filter.atTop
-- Filter.Ici_mem_atTop
theorem Ici_mem_atTop [Preorder α] (a : α) : Ici a ∈ (atTop : Filter α) 
Arguments: {α : Type u_3} [Preorder α] (a : α)
Goal: Set.Ici a ∈ Filter.atTop
-- Filter.Ioi_mem_atTop
theorem Ioi_mem_atTop [Preorder α] [NoMaxOrder α] (x : α) : Ioi x ∈ (atTop : Filter α) 
Arguments: {α : Type u_3} [Preorder α] [NoMaxOrder α] (x : α)
Goal: Set.Ioi x ∈ Filter.atTop
-- Filter.mem_atBot
theorem mem_atBot [Preorder α] (a : α) : { b : α | b ≤ a } ∈ @atBot α _ 
Arguments: {α : Type u_3} [Preorder α] (a : α)
Goal: {b | b ≤ a} ∈ Filter.atBot
-- Filter.Iic_mem_atBot
theorem Iic_mem_atBot [Preorder α] (a : α) : Iic a ∈ (atBot : Filter α) 
Arguments: {α : Type u_3} [Preorder α] (a : α)
Goal: Set.Iic a ∈ Filter.atBot
-- Filter.Iio_mem_atBot
theorem Iio_mem_atBot [Preorder α] [NoMinOrder α] (x : α) : Iio x ∈ (atBot : Filter α) 
Arguments: {α : Type u_3} [Preorder α] [NoMinOrder α] (x : α)
Goal: Set.Iio x ∈ Filter.atBot
-- Filter.disjoint_atBot_principal_Ioi
theorem disjoint_atBot_principal_Ioi [Preorder α] (x : α) : Disjoint atBot (𝓟 (Ioi x)) 
Arguments: {α : Type u_3} [Preorder α] (x : α)
Goal: Disjoint Filter.atBot (𝓟 (Set.Ioi x))
-- Filter.disjoint_atTop_principal_Iio
theorem disjoint_atTop_principal_Iio [Preorder α] (x : α) : Disjoint atTop (𝓟 (Iio x)) 
Arguments: {α : Type u_3} [Preorder α] (x : α)
Goal: Disjoint Filter.atTop (𝓟 (Set.Iio x))
-- Filter.disjoint_atTop_principal_Iic
theorem disjoint_atTop_principal_Iic [Preorder α] [NoMaxOrder α] (x : α) :
    Disjoint atTop (𝓟 (Iic x)) 
Arguments: {α : Type u_3} [Preorder α] [NoMaxOrder α] (x : α)
Goal: Disjoint Filter.atTop (𝓟 (Set.Iic x))
-- Filter.disjoint_atBot_principal_Ici
theorem disjoint_atBot_principal_Ici [Preorder α] [NoMinOrder α] (x : α) :
    Disjoint atBot (𝓟 (Ici x)) 
Arguments: {α : Type u_3} [Preorder α] [NoMinOrder α] (x : α)
Goal: Disjoint Filter.atBot (𝓟 (Set.Ici x))
-- Filter.disjoint_pure_atTop
theorem disjoint_pure_atTop [Preorder α] [NoMaxOrder α] (x : α) : Disjoint (pure x) atTop 
Arguments: {α : Type u_3} [Preorder α] [NoMaxOrder α] (x : α)
Goal: Disjoint (pure x) Filter.atTop
-- Filter.disjoint_pure_atBot
theorem disjoint_pure_atBot [Preorder α] [NoMinOrder α] (x : α) : Disjoint (pure x) atBot 
Arguments: {α : Type u_3} [Preorder α] [NoMinOrder α] (x : α)
Goal: Disjoint (pure x) Filter.atBot
-- Filter.not_tendsto_const_atTop
theorem not_tendsto_const_atTop [Preorder α] [NoMaxOrder α] (x : α) (l : Filter β) [l.NeBot] :
    ¬Tendsto (fun _ => x) l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder α] [NoMaxOrder α] (x : α) (l : Filter β) [l.NeBot]
Goal: ¬Filter.Tendsto (fun x_1 => x) l Filter.atTop
-- Filter.not_tendsto_const_atBot
theorem not_tendsto_const_atBot [Preorder α] [NoMinOrder α] (x : α) (l : Filter β) [l.NeBot] :
    ¬Tendsto (fun _ => x) l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder α] [NoMinOrder α] (x : α) (l : Filter β) [l.NeBot]
Goal: ¬Filter.Tendsto (fun x_1 => x) l Filter.atBot
-- Filter.disjoint_atBot_atTop
theorem disjoint_atBot_atTop [PartialOrder α] [Nontrivial α] :
    Disjoint (atBot : Filter α) atTop 
Arguments: {α : Type u_3} [PartialOrder α] [Nontrivial α]
Goal: Disjoint Filter.atBot Filter.atTop
-- Filter.disjoint_atTop_atBot
theorem disjoint_atTop_atBot [PartialOrder α] [Nontrivial α] : Disjoint (atTop : Filter α) atBot 
Arguments: {α : Type u_3} [PartialOrder α] [Nontrivial α]
Goal: Disjoint Filter.atTop Filter.atBot
-- Filter.hasAntitoneBasis_atTop
theorem hasAntitoneBasis_atTop [Nonempty α] [Preorder α] [IsDirected α (· ≤ ·)] :
    (@atTop α _).HasAntitoneBasis Ici 
Arguments: {α : Type u_3} [Nonempty α] [Preorder α] [IsDirected α fun x x_1 => x ≤ x_1]
Goal: Filter.atTop.HasAntitoneBasis Set.Ici
-- Filter.atTop_basis
theorem atTop_basis [Nonempty α] [SemilatticeSup α] : (@atTop α _).HasBasis (fun _ => True) Ici 
Arguments: {α : Type u_3} [Nonempty α] [SemilatticeSup α]
Goal: Filter.atTop.HasBasis (fun x => True) Set.Ici
-- Filter.atTop_eq_generate_Ici
theorem atTop_eq_generate_Ici [SemilatticeSup α] : atTop = generate (range (Ici (α := α))) 
Arguments: {α : Type u_3} [SemilatticeSup α]
Goal: Filter.atTop = Filter.generate (Set.range Set.Ici)
-- Filter.atTop_basis'
theorem atTop_basis' [SemilatticeSup α] (a : α) : (@atTop α _).HasBasis (fun x => a ≤ x) Ici 
Arguments: {α : Type u_3} [SemilatticeSup α] (a : α)
Goal: Filter.atTop.HasBasis (fun x => a ≤ x) Set.Ici
-- Filter.atBot_basis
theorem atBot_basis [Nonempty α] [SemilatticeInf α] : (@atBot α _).HasBasis (fun _ => True) Iic 
Arguments: {α : Type u_3} [Nonempty α] [SemilatticeInf α]
Goal: Filter.atBot.HasBasis (fun x => True) Set.Iic
-- Filter.atBot_basis'
theorem atBot_basis' [SemilatticeInf α] (a : α) : (@atBot α _).HasBasis (fun x => x ≤ a) Iic 
Arguments: {α : Type u_3} [SemilatticeInf α] (a : α)
Goal: Filter.atBot.HasBasis (fun x => x ≤ a) Set.Iic
-- Filter.atTop_neBot
@[instance]
theorem atTop_neBot [Nonempty α] [SemilatticeSup α] : NeBot (atTop : Filter α) 
Arguments: {α : Type u_3} [Nonempty α] [SemilatticeSup α]
Goal: Filter.atTop.NeBot
-- Filter.atBot_neBot
@[instance]
theorem atBot_neBot [Nonempty α] [SemilatticeInf α] : NeBot (atBot : Filter α) 
Arguments: {α : Type u_3} [Nonempty α] [SemilatticeInf α]
Goal: Filter.atBot.NeBot
-- Filter.mem_atTop_sets
@[simp]
theorem mem_atTop_sets [Nonempty α] [SemilatticeSup α] {s : Set α} :
    s ∈ (atTop : Filter α) ↔ ∃ a : α, ∀ b ≥ a, b ∈ s 
Arguments: {α : Type u_3} [Nonempty α] [SemilatticeSup α] {s : Set α}
Goal: s ∈ Filter.atTop ↔ ∃ a, ∀ b ≥ a, b ∈ s
-- Filter.mem_atBot_sets
@[simp]
theorem mem_atBot_sets [Nonempty α] [SemilatticeInf α] {s : Set α} :
    s ∈ (atBot : Filter α) ↔ ∃ a : α, ∀ b ≤ a, b ∈ s 
Arguments: {α : Type u_3} [Nonempty α] [SemilatticeInf α] {s : Set α}
Goal: s ∈ Filter.atBot ↔ ∃ a, ∀ b ≤ a, b ∈ s
-- Filter.eventually_atTop
@[simp]
theorem eventually_atTop [SemilatticeSup α] [Nonempty α] {p : α → Prop} :
    (∀ᶠ x in atTop, p x) ↔ ∃ a, ∀ b ≥ a, p b 
Arguments: {α : Type u_3} [SemilatticeSup α] [Nonempty α] {p : α → Prop}
Goal: (∀ᶠ (x : α) in Filter.atTop, p x) ↔ ∃ a, ∀ b ≥ a, p b
-- Filter.eventually_atBot
@[simp]
theorem eventually_atBot [SemilatticeInf α] [Nonempty α] {p : α → Prop} :
    (∀ᶠ x in atBot, p x) ↔ ∃ a, ∀ b ≤ a, p b 
Arguments: {α : Type u_3} [SemilatticeInf α] [Nonempty α] {p : α → Prop}
Goal: (∀ᶠ (x : α) in Filter.atBot, p x) ↔ ∃ a, ∀ b ≤ a, p b
-- Filter.eventually_ge_atTop
theorem eventually_ge_atTop [Preorder α] (a : α) : ∀ᶠ x in atTop, a ≤ x 
Arguments: {α : Type u_3} [Preorder α] (a : α)
Goal: ∀ᶠ (x : α) in Filter.atTop, a ≤ x
-- Filter.eventually_le_atBot
theorem eventually_le_atBot [Preorder α] (a : α) : ∀ᶠ x in atBot, x ≤ a 
Arguments: {α : Type u_3} [Preorder α] (a : α)
Goal: ∀ᶠ (x : α) in Filter.atBot, x ≤ a
-- Filter.eventually_gt_atTop
theorem eventually_gt_atTop [Preorder α] [NoMaxOrder α] (a : α) : ∀ᶠ x in atTop, a < x 
Arguments: {α : Type u_3} [Preorder α] [NoMaxOrder α] (a : α)
Goal: ∀ᶠ (x : α) in Filter.atTop, a < x
-- Filter.eventually_ne_atTop
theorem eventually_ne_atTop [Preorder α] [NoMaxOrder α] (a : α) : ∀ᶠ x in atTop, x ≠ a 
Arguments: {α : Type u_3} [Preorder α] [NoMaxOrder α] (a : α)
Goal: ∀ᶠ (x : α) in Filter.atTop, x ≠ a
-- Filter.Tendsto.eventually_gt_atTop
protected theorem Tendsto.eventually_gt_atTop [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atTop) (c : β) : ∀ᶠ x in l, c < f x 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α} (hf : Filter.Tendsto f l Filter.atTop) (c : β)
Goal: ∀ᶠ (x : α) in l, c < f x
-- Filter.Tendsto.eventually_ge_atTop
protected theorem Tendsto.eventually_ge_atTop [Preorder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atTop) (c : β) : ∀ᶠ x in l, c ≤ f x 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] {f : α → β} {l : Filter α} (hf : Filter.Tendsto f l Filter.atTop) (c : β)
Goal: ∀ᶠ (x : α) in l, c ≤ f x
-- Filter.Tendsto.eventually_ne_atTop
protected theorem Tendsto.eventually_ne_atTop [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atTop) (c : β) : ∀ᶠ x in l, f x ≠ c 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α} (hf : Filter.Tendsto f l Filter.atTop) (c : β)
Goal: ∀ᶠ (x : α) in l, f x ≠ c
-- Filter.Tendsto.eventually_ne_atTop'
protected theorem Tendsto.eventually_ne_atTop' [Preorder β] [NoMaxOrder β] {f : α → β}
    {l : Filter α} (hf : Tendsto f l atTop) (c : α) : ∀ᶠ x in l, x ≠ c 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α} (hf : Filter.Tendsto f l Filter.atTop) (c : α)
Goal: ∀ᶠ (x : α) in l, x ≠ c
-- Filter.eventually_lt_atBot
theorem eventually_lt_atBot [Preorder α] [NoMinOrder α] (a : α) : ∀ᶠ x in atBot, x < a 
Arguments: {α : Type u_3} [Preorder α] [NoMinOrder α] (a : α)
Goal: ∀ᶠ (x : α) in Filter.atBot, x < a
-- Filter.eventually_ne_atBot
theorem eventually_ne_atBot [Preorder α] [NoMinOrder α] (a : α) : ∀ᶠ x in atBot, x ≠ a 
Arguments: {α : Type u_3} [Preorder α] [NoMinOrder α] (a : α)
Goal: ∀ᶠ (x : α) in Filter.atBot, x ≠ a
-- Filter.Tendsto.eventually_lt_atBot
protected theorem Tendsto.eventually_lt_atBot [Preorder β] [NoMinOrder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atBot) (c : β) : ∀ᶠ x in l, f x < c 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] [NoMinOrder β] {f : α → β} {l : Filter α} (hf : Filter.Tendsto f l Filter.atBot) (c : β)
Goal: ∀ᶠ (x : α) in l, f x < c
-- Filter.Tendsto.eventually_le_atBot
protected theorem Tendsto.eventually_le_atBot [Preorder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atBot) (c : β) : ∀ᶠ x in l, f x ≤ c 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] {f : α → β} {l : Filter α} (hf : Filter.Tendsto f l Filter.atBot) (c : β)
Goal: ∀ᶠ (x : α) in l, f x ≤ c
-- Filter.Tendsto.eventually_ne_atBot
protected theorem Tendsto.eventually_ne_atBot [Preorder β] [NoMinOrder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atBot) (c : β) : ∀ᶠ x in l, f x ≠ c 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] [NoMinOrder β] {f : α → β} {l : Filter α} (hf : Filter.Tendsto f l Filter.atBot) (c : β)
Goal: ∀ᶠ (x : α) in l, f x ≠ c
-- Filter.eventually_forall_ge_atTop
theorem eventually_forall_ge_atTop [Preorder α] {p : α → Prop} :
    (∀ᶠ x in atTop, ∀ y, x ≤ y → p y) ↔ ∀ᶠ x in atTop, p x 
Arguments: {α : Type u_3} [Preorder α] {p : α → Prop}
Goal: (∀ᶠ (x : α) in Filter.atTop, ∀ (y : α), x ≤ y → p y) ↔ ∀ᶠ (x : α) in Filter.atTop, p x
-- Filter.eventually_forall_le_atBot
theorem eventually_forall_le_atBot [Preorder α] {p : α → Prop} :
    (∀ᶠ x in atBot, ∀ y, y ≤ x → p y) ↔ ∀ᶠ x in atBot, p x 
Arguments: {α : Type u_3} [Preorder α] {p : α → Prop}
Goal: (∀ᶠ (x : α) in Filter.atBot, ∀ y ≤ x, p y) ↔ ∀ᶠ (x : α) in Filter.atBot, p x