ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Filter.Tendsto.eventually_forall_ge_atTop
theorem Tendsto.eventually_forall_ge_atTop [Preorder β] {l : Filter α}
    {p : β → Prop} {f : α → β} (hf : Tendsto f l atTop) (h_evtl : ∀ᶠ x in atTop, p x) :
    ∀ᶠ x in l, ∀ y, f x ≤ y → p y 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] {l : Filter α} {p : β → Prop} {f : α → β} (hf : Filter.Tendsto f l Filter.atTop) (h_evtl : ∀ᶠ (x : β) in Filter.atTop, p x)
Goal: ∀ᶠ (x : α) in l, ∀ (y : β), f x ≤ y → p y
-- Filter.Tendsto.eventually_forall_le_atBot
theorem Tendsto.eventually_forall_le_atBot [Preorder β] {l : Filter α}
    {p : β → Prop} {f : α → β} (hf : Tendsto f l atBot) (h_evtl : ∀ᶠ x in atBot, p x) :
    ∀ᶠ x in l, ∀ y, y ≤ f x → p y 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] {l : Filter α} {p : β → Prop} {f : α → β} (hf : Filter.Tendsto f l Filter.atBot) (h_evtl : ∀ᶠ (x : β) in Filter.atBot, p x)
Goal: ∀ᶠ (x : α) in l, ∀ y ≤ f x, p y
-- Filter.atTop_basis_Ioi
theorem atTop_basis_Ioi [Nonempty α] [SemilatticeSup α] [NoMaxOrder α] :
    (@atTop α _).HasBasis (fun _ => True) Ioi 
Arguments: {α : Type u_3} [Nonempty α] [SemilatticeSup α] [NoMaxOrder α]
Goal: Filter.atTop.HasBasis (fun x => True) Set.Ioi
-- Filter.atTop_basis_Ioi'
lemma atTop_basis_Ioi' [SemilatticeSup α] [NoMaxOrder α] (a : α) : atTop.HasBasis (a < ·) Ioi 
Arguments: {α : Type u_3} [SemilatticeSup α] [NoMaxOrder α] (a : α)
Goal: Filter.atTop.HasBasis (fun x => a < x) Set.Ioi
-- Filter.atTop_countable_basis
theorem atTop_countable_basis [Nonempty α] [SemilatticeSup α] [Countable α] :
    HasCountableBasis (atTop : Filter α) (fun _ => True) Ici 
Arguments: {α : Type u_3} [Nonempty α] [SemilatticeSup α] [Countable α]
Goal: Filter.atTop.HasCountableBasis (fun x => True) Set.Ici
-- Filter.atBot_countable_basis
theorem atBot_countable_basis [Nonempty α] [SemilatticeInf α] [Countable α] :
    HasCountableBasis (atBot : Filter α) (fun _ => True) Iic 
Arguments: {α : Type u_3} [Nonempty α] [SemilatticeInf α] [Countable α]
Goal: Filter.atBot.HasCountableBasis (fun x => True) Set.Iic
-- IsTop.atTop_eq
theorem _root_.IsTop.atTop_eq [Preorder α] {a : α} (ha : IsTop a) : atTop = 𝓟 (Ici a) 
Arguments: {α : Type u_3} [Preorder α] {a : α} (ha : IsTop a)
Goal: Filter.atTop = 𝓟 (Set.Ici a)
-- IsBot.atBot_eq
theorem _root_.IsBot.atBot_eq [Preorder α] {a : α} (ha : IsBot a) : atBot = 𝓟 (Iic a) 
Arguments: {α : Type u_3} [Preorder α] {a : α} (ha : IsBot a)
Goal: Filter.atBot = 𝓟 (Set.Iic a)
-- Filter.OrderTop.atTop_eq
theorem OrderTop.atTop_eq (α) [PartialOrder α] [OrderTop α] : (atTop : Filter α) = pure ⊤ 
Arguments: (α : Type u_6) [PartialOrder α] [OrderTop α]
Goal: Filter.atTop = pure ⊤
-- Filter.OrderBot.atBot_eq
theorem OrderBot.atBot_eq (α) [PartialOrder α] [OrderBot α] : (atBot : Filter α) = pure ⊥ 
Arguments: (α : Type u_6) [PartialOrder α] [OrderBot α]
Goal: Filter.atBot = pure ⊥
-- Filter.Subsingleton.atTop_eq
@[nontriviality]
theorem Subsingleton.atTop_eq (α) [Subsingleton α] [Preorder α] : (atTop : Filter α) = ⊤ 
Arguments: (α : Type u_6) [Subsingleton α] [Preorder α]
Goal: Filter.atTop = ⊤
-- Filter.Subsingleton.atBot_eq
@[nontriviality]
theorem Subsingleton.atBot_eq (α) [Subsingleton α] [Preorder α] : (atBot : Filter α) = ⊤ 
Arguments: (α : Type u_6) [Subsingleton α] [Preorder α]
Goal: Filter.atBot = ⊤
-- Filter.tendsto_atTop_pure
theorem tendsto_atTop_pure [PartialOrder α] [OrderTop α] (f : α → β) :
    Tendsto f atTop (pure <| f ⊤) 
Arguments: {α : Type u_3} {β : Type u_4} [PartialOrder α] [OrderTop α] (f : α → β)
Goal: Filter.Tendsto f Filter.atTop (pure (f ⊤))
-- Filter.tendsto_atBot_pure
theorem tendsto_atBot_pure [PartialOrder α] [OrderBot α] (f : α → β) :
    Tendsto f atBot (pure <| f ⊥) 
Arguments: {α : Type u_3} {β : Type u_4} [PartialOrder α] [OrderBot α] (f : α → β)
Goal: Filter.Tendsto f Filter.atBot (pure (f ⊥))
-- Filter.Eventually.exists_forall_of_atTop
theorem Eventually.exists_forall_of_atTop [SemilatticeSup α] [Nonempty α] {p : α → Prop}
    (h : ∀ᶠ x in atTop, p x) : ∃ a, ∀ b ≥ a, p b 
Arguments: {α : Type u_3} [SemilatticeSup α] [Nonempty α] {p : α → Prop} (h : ∀ᶠ (x : α) in Filter.atTop, p x)
Goal: ∃ a, ∀ b ≥ a, p b
-- Filter.Eventually.exists_forall_of_atBot
theorem Eventually.exists_forall_of_atBot [SemilatticeInf α] [Nonempty α] {p : α → Prop}
    (h : ∀ᶠ x in atBot, p x) : ∃ a, ∀ b ≤ a, p b 
Arguments: {α : Type u_3} [SemilatticeInf α] [Nonempty α] {p : α → Prop} (h : ∀ᶠ (x : α) in Filter.atBot, p x)
Goal: ∃ a, ∀ b ≤ a, p b
-- Filter.exists_eventually_atTop
lemma exists_eventually_atTop [SemilatticeSup α] [Nonempty α] {r : α → β → Prop} :
    (∃ b, ∀ᶠ a in atTop, r a b) ↔ ∀ᶠ a₀ in atTop, ∃ b, ∀ a ≥ a₀, r a b 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeSup α] [Nonempty α] {r : α → β → Prop}
Goal: (∃ b, ∀ᶠ (a : α) in Filter.atTop, r a b) ↔ ∀ᶠ (a₀ : α) in Filter.atTop, ∃ b, ∀ a ≥ a₀, r a b
-- Filter.exists_eventually_atBot
lemma exists_eventually_atBot [SemilatticeInf α] [Nonempty α] {r : α → β → Prop} :
    (∃ b, ∀ᶠ a in atBot, r a b) ↔ ∀ᶠ a₀ in atBot, ∃ b, ∀ a ≤ a₀, r a b 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeInf α] [Nonempty α] {r : α → β → Prop}
Goal: (∃ b, ∀ᶠ (a : α) in Filter.atBot, r a b) ↔ ∀ᶠ (a₀ : α) in Filter.atBot, ∃ b, ∀ a ≤ a₀, r a b
-- Filter.frequently_atTop
theorem frequently_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.frequently_atBot
theorem frequently_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.frequently_atTop'
theorem frequently_atTop' [SemilatticeSup α] [Nonempty α] [NoMaxOrder α] {p : α → Prop} :
    (∃ᶠ x in atTop, p x) ↔ ∀ a, ∃ b > a, p b 
Arguments: {α : Type u_3} [SemilatticeSup α] [Nonempty α] [NoMaxOrder α] {p : α → Prop}
Goal: (∃ᶠ (x : α) in Filter.atTop, p x) ↔ ∀ (a : α), ∃ b > a, p b
-- Filter.frequently_atBot'
theorem frequently_atBot' [SemilatticeInf α] [Nonempty α] [NoMinOrder α] {p : α → Prop} :
    (∃ᶠ x in atBot, p x) ↔ ∀ a, ∃ b < a, p b 
Arguments: {α : Type u_3} [SemilatticeInf α] [Nonempty α] [NoMinOrder α] {p : α → Prop}
Goal: (∃ᶠ (x : α) in Filter.atBot, p x) ↔ ∀ (a : α), ∃ b < a, p b
-- Filter.Frequently.forall_exists_of_atTop
theorem Frequently.forall_exists_of_atTop [SemilatticeSup α] [Nonempty α] {p : α → Prop}
    (h : ∃ᶠ x in atTop, p x) : ∀ a, ∃ b ≥ a, p b 
Arguments: {α : Type u_3} [SemilatticeSup α] [Nonempty α] {p : α → Prop} (h : ∃ᶠ (x : α) in Filter.atTop, p x) (a : α)
Goal: ∃ b ≥ a, p b
-- Filter.Frequently.forall_exists_of_atBot
theorem Frequently.forall_exists_of_atBot [SemilatticeInf α] [Nonempty α] {p : α → Prop}
    (h : ∃ᶠ x in atBot, p x) : ∀ a, ∃ b ≤ a, p b 
Arguments: {α : Type u_3} [SemilatticeInf α] [Nonempty α] {p : α → Prop} (h : ∃ᶠ (x : α) in Filter.atBot, p x) (a : α)
Goal: ∃ b ≤ a, p b
-- Filter.map_atTop_eq
theorem map_atTop_eq [Nonempty α] [SemilatticeSup α] {f : α → β} :
    atTop.map f = ⨅ a, 𝓟 (f '' { a' | a ≤ a' }) 
Arguments: {α : Type u_3} {β : Type u_4} [Nonempty α] [SemilatticeSup α] {f : α → β}
Goal: Filter.map f Filter.atTop = ⨅ a, 𝓟 (f '' {a' | a ≤ a'})
-- Filter.map_atBot_eq
theorem map_atBot_eq [Nonempty α] [SemilatticeInf α] {f : α → β} :
    atBot.map f = ⨅ a, 𝓟 (f '' { a' | a' ≤ a }) 
Arguments: {α : Type u_3} {β : Type u_4} [Nonempty α] [SemilatticeInf α] {f : α → β}
Goal: Filter.map f Filter.atBot = ⨅ a, 𝓟 (f '' {a' | a' ≤ a})
-- Filter.tendsto_atTop
theorem tendsto_atTop [Preorder β] {m : α → β} {f : Filter α} :
    Tendsto m f atTop ↔ ∀ b, ∀ᶠ a in f, b ≤ m a 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] {m : α → β} {f : Filter α}
Goal: Filter.Tendsto m f Filter.atTop ↔ ∀ (b : β), ∀ᶠ (a : α) in f, b ≤ m a
-- Filter.tendsto_atBot
theorem tendsto_atBot [Preorder β] {m : α → β} {f : Filter α} :
    Tendsto m f atBot ↔ ∀ b, ∀ᶠ a in f, m a ≤ b 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] {m : α → β} {f : Filter α}
Goal: Filter.Tendsto m f Filter.atBot ↔ ∀ (b : β), ∀ᶠ (a : α) in f, m a ≤ b
-- Filter.tendsto_atTop_mono'
theorem tendsto_atTop_mono' [Preorder β] (l : Filter α) ⦃f₁ f₂ : α → β⦄ (h : f₁ ≤ᶠ[l] f₂)
    (h₁ : Tendsto f₁ l atTop) : Tendsto f₂ l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] (l : Filter α) ⦃f₁ f₂ : α → β⦄ (h : f₁ ≤ᶠ[l] f₂) (h₁ : Filter.Tendsto f₁ l Filter.atTop)
Goal: Filter.Tendsto f₂ l Filter.atTop
-- Filter.tendsto_atBot_mono'
theorem tendsto_atBot_mono' [Preorder β] (l : Filter α) ⦃f₁ f₂ : α → β⦄ (h : f₁ ≤ᶠ[l] f₂) :
    Tendsto f₂ l atBot → Tendsto f₁ l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] (l : Filter α) ⦃f₁ f₂ : α → β⦄ (h : f₁ ≤ᶠ[l] f₂)
Goal: Filter.Tendsto f₂ l Filter.atBot → Filter.Tendsto f₁ l Filter.atBot
-- Filter.tendsto_atTop_mono
theorem tendsto_atTop_mono [Preorder β] {l : Filter α} {f g : α → β} (h : ∀ n, f n ≤ g n) :
    Tendsto f l atTop → Tendsto g l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] {l : Filter α} {f g : α → β} (h : ∀ (n : α), f n ≤ g n)
Goal: Filter.Tendsto f l Filter.atTop → Filter.Tendsto g l Filter.atTop
-- Filter.tendsto_atBot_mono
theorem tendsto_atBot_mono [Preorder β] {l : Filter α} {f g : α → β} (h : ∀ n, f n ≤ g n) :
    Tendsto g l atBot → Tendsto f l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder β] {l : Filter α} {f g : α → β} (h : ∀ (n : α), f n ≤ g n)
Goal: Filter.Tendsto g l Filter.atBot → Filter.Tendsto f l Filter.atBot
-- Filter.atTop_eq_generate_of_forall_exists_le
lemma atTop_eq_generate_of_forall_exists_le [LinearOrder α] {s : Set α} (hs : ∀ x, ∃ y ∈ s, x ≤ y) :
    (atTop : Filter α) = generate (Ici '' s) 
Arguments: {α : Type u_3} [LinearOrder α] {s : Set α} (hs : ∀ (x : α), ∃ y ∈ s, x ≤ y)
Goal: Filter.atTop = Filter.generate (Set.Ici '' s)
-- Filter.atTop_eq_generate_of_not_bddAbove
lemma atTop_eq_generate_of_not_bddAbove [LinearOrder α] {s : Set α} (hs : ¬ BddAbove s) :
    (atTop : Filter α) = generate (Ici '' s) 
Arguments: {α : Type u_3} [LinearOrder α] {s : Set α} (hs : ¬BddAbove s)
Goal: Filter.atTop = Filter.generate (Set.Ici '' s)
-- OrderIso.comap_atTop
@[simp]
theorem comap_atTop (e : α ≃o β) : comap e atTop = atTop 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder α] [Preorder β] (e : α ≃o β)
Goal: Filter.comap (⇑e) Filter.atTop = Filter.atTop
-- OrderIso.comap_atBot
@[simp]
theorem comap_atBot (e : α ≃o β) : comap e atBot = atBot 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder α] [Preorder β] (e : α ≃o β)
Goal: Filter.comap (⇑e) Filter.atBot = Filter.atBot
-- OrderIso.map_atTop
@[simp]
theorem map_atTop (e : α ≃o β) : map (e : α → β) atTop = atTop 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder α] [Preorder β] (e : α ≃o β)
Goal: Filter.map (⇑e) Filter.atTop = Filter.atTop
-- OrderIso.map_atBot
@[simp]
theorem map_atBot (e : α ≃o β) : map (e : α → β) atBot = atBot 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder α] [Preorder β] (e : α ≃o β)
Goal: Filter.map (⇑e) Filter.atBot = Filter.atBot
-- OrderIso.tendsto_atTop
theorem tendsto_atTop (e : α ≃o β) : Tendsto e atTop atTop 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder α] [Preorder β] (e : α ≃o β)
Goal: Filter.Tendsto (⇑e) Filter.atTop Filter.atTop
-- OrderIso.tendsto_atBot
theorem tendsto_atBot (e : α ≃o β) : Tendsto e atBot atBot 
Arguments: {α : Type u_3} {β : Type u_4} [Preorder α] [Preorder β] (e : α ≃o β)
Goal: Filter.Tendsto (⇑e) Filter.atBot Filter.atBot
-- OrderIso.tendsto_atTop_iff
@[simp]
theorem tendsto_atTop_iff {l : Filter γ} {f : γ → α} (e : α ≃o β) :
    Tendsto (fun x => e (f x)) l atTop ↔ Tendsto f l atTop 
Arguments: {α : Type u_3} {β : Type u_4} {γ : Type u_5} [Preorder α] [Preorder β] {l : Filter γ} {f : γ → α} (e : α ≃o β)
Goal: Filter.Tendsto (fun x => e (f x)) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop
-- OrderIso.tendsto_atBot_iff
@[simp]
theorem tendsto_atBot_iff {l : Filter γ} {f : γ → α} (e : α ≃o β) :
    Tendsto (fun x => e (f x)) l atBot ↔ Tendsto f l atBot 
Arguments: {α : Type u_3} {β : Type u_4} {γ : Type u_5} [Preorder α] [Preorder β] {l : Filter γ} {f : γ → α} (e : α ≃o β)
Goal: Filter.Tendsto (fun x => e (f x)) l Filter.atBot ↔ Filter.Tendsto f l Filter.atBot
-- Filter.inf_map_atTop_neBot_iff
theorem inf_map_atTop_neBot_iff [SemilatticeSup α] [Nonempty α] {F : Filter β} {u : α → β} :
    NeBot (F ⊓ map u atTop) ↔ ∀ U ∈ F, ∀ N, ∃ n ≥ N, u n ∈ U 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeSup α] [Nonempty α] {F : Filter β} {u : α → β}
Goal: (F ⊓ Filter.map u Filter.atTop).NeBot ↔ ∀ U ∈ F, ∀ (N : α), ∃ n ≥ N, u n ∈ U
-- Filter.inf_map_atBot_neBot_iff
theorem inf_map_atBot_neBot_iff [SemilatticeInf α] [Nonempty α] {F : Filter β} {u : α → β} :
    NeBot (F ⊓ map u atBot) ↔ ∀ U ∈ F, ∀ N, ∃ n ≤ N, u n ∈ U 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeInf α] [Nonempty α] {F : Filter β} {u : α → β}
Goal: (F ⊓ Filter.map u Filter.atBot).NeBot ↔ ∀ U ∈ F, ∀ (N : α), ∃ n ≤ N, u n ∈ U
-- Filter.extraction_of_frequently_atTop'
theorem extraction_of_frequently_atTop' {P : ℕ → Prop} (h : ∀ N, ∃ n > N, P n) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ n, P (φ n) 
Arguments: {P : ℕ → Prop} (h : ∀ (N : ℕ), ∃ n > N, P n)
Goal: ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)
-- Filter.extraction_of_frequently_atTop
theorem extraction_of_frequently_atTop {P : ℕ → Prop} (h : ∃ᶠ n in atTop, P n) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ n, P (φ n) 
Arguments: {P : ℕ → Prop} (h : ∃ᶠ (n : ℕ) in Filter.atTop, P n)
Goal: ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)
-- Filter.extraction_of_eventually_atTop
theorem extraction_of_eventually_atTop {P : ℕ → Prop} (h : ∀ᶠ n in atTop, P n) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ n, P (φ n) 
Arguments: {P : ℕ → Prop} (h : ∀ᶠ (n : ℕ) in Filter.atTop, P n)
Goal: ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)
-- Filter.extraction_forall_of_frequently
theorem extraction_forall_of_frequently {P : ℕ → ℕ → Prop} (h : ∀ n, ∃ᶠ k in atTop, P n k) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ n, P n (φ n) 
Arguments: {P : ℕ → ℕ → Prop} (h : ∀ (n : ℕ), ∃ᶠ (k : ℕ) in Filter.atTop, P n k)
Goal: ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)
-- Filter.extraction_forall_of_eventually
theorem extraction_forall_of_eventually {P : ℕ → ℕ → Prop} (h : ∀ n, ∀ᶠ k in atTop, P n k) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ n, P n (φ n) 
Arguments: {P : ℕ → ℕ → Prop} (h : ∀ (n : ℕ), ∀ᶠ (k : ℕ) in Filter.atTop, P n k)
Goal: ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)
-- Filter.extraction_forall_of_eventually'
theorem extraction_forall_of_eventually' {P : ℕ → ℕ → Prop} (h : ∀ n, ∃ N, ∀ k ≥ N, P n k) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ n, P n (φ n) 
Arguments: {P : ℕ → ℕ → Prop} (h : ∀ (n : ℕ), ∃ N, ∀ k ≥ N, P n k)
Goal: ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)
-- Filter.Eventually.atTop_of_arithmetic
theorem Eventually.atTop_of_arithmetic {p : ℕ → Prop} {n : ℕ} (hn : n ≠ 0)
    (hp : ∀ k < n, ∀ᶠ a in atTop, p (n * a + k)) : ∀ᶠ a in atTop, p a 
Arguments: {p : ℕ → Prop} {n : ℕ} (hn : n ≠ 0) (hp : ∀ k < n, ∀ᶠ (a : ℕ) in Filter.atTop, p (n * a + k))
Goal: ∀ᶠ (a : ℕ) in Filter.atTop, p a
-- Filter.exists_le_of_tendsto_atTop
theorem exists_le_of_tendsto_atTop [SemilatticeSup α] [Preorder β] {u : α → β}
    (h : Tendsto u atTop atTop) (a : α) (b : β) : ∃ a' ≥ a, b ≤ u a' 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeSup α] [Preorder β] {u : α → β} (h : Filter.Tendsto u Filter.atTop Filter.atTop) (a : α) (b : β)
Goal: ∃ a' ≥ a, b ≤ u a'
-- Filter.exists_le_of_tendsto_atBot
theorem exists_le_of_tendsto_atBot [SemilatticeSup α] [Preorder β] {u : α → β}
    (h : Tendsto u atTop atBot) : ∀ a b, ∃ a' ≥ a, u a' ≤ b 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeSup α] [Preorder β] {u : α → β} (h : Filter.Tendsto u Filter.atTop Filter.atBot) (a : α) (b : β)
Goal: ∃ a' ≥ a, u a' ≤ b
-- Filter.exists_lt_of_tendsto_atTop
theorem exists_lt_of_tendsto_atTop [SemilatticeSup α] [Preorder β] [NoMaxOrder β] {u : α → β}
    (h : Tendsto u atTop atTop) (a : α) (b : β) : ∃ a' ≥ a, b < u a' 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeSup α] [Preorder β] [NoMaxOrder β] {u : α → β} (h : Filter.Tendsto u Filter.atTop Filter.atTop) (a : α) (b : β)
Goal: ∃ a' ≥ a, b < u a'
-- Filter.exists_lt_of_tendsto_atBot
theorem exists_lt_of_tendsto_atBot [SemilatticeSup α] [Preorder β] [NoMinOrder β] {u : α → β}
    (h : Tendsto u atTop atBot) : ∀ a b, ∃ a' ≥ a, u a' < b 
Arguments: {α : Type u_3} {β : Type u_4} [SemilatticeSup α] [Preorder β] [NoMinOrder β] {u : α → β} (h : Filter.Tendsto u Filter.atTop Filter.atBot) (a : α) (b : β)
Goal: ∃ a' ≥ a, u a' < b
-- Filter.high_scores
theorem high_scores [LinearOrder β] [NoMaxOrder β] {u : ℕ → β} (hu : Tendsto u atTop atTop) :
    ∀ N, ∃ n ≥ N, ∀ k < n, u k < u n 
Arguments: {β : Type u_4} [LinearOrder β] [NoMaxOrder β] {u : ℕ → β} (hu : Filter.Tendsto u Filter.atTop Filter.atTop) (N : ℕ)
Goal: ∃ n ≥ N, ∀ k < n, u k < u n
-- Filter.low_scores
-- @[nolint ge_or_gt] Porting note: restore attribute
theorem low_scores [LinearOrder β] [NoMinOrder β] {u : ℕ → β} (hu : Tendsto u atTop atBot) :
    ∀ N, ∃ n ≥ N, ∀ k < n, u n < u k 
Arguments: {β : Type u_4} [LinearOrder β] [NoMinOrder β] {u : ℕ → β} (hu : Filter.Tendsto u Filter.atTop Filter.atBot) (N : ℕ)
Goal: ∃ n ≥ N, ∀ k < n, u n < u k
-- Filter.frequently_high_scores
theorem frequently_high_scores [LinearOrder β] [NoMaxOrder β] {u : ℕ → β}
    (hu : Tendsto u atTop atTop) : ∃ᶠ n in atTop, ∀ k < n, u k < u n 
Arguments: {β : Type u_4} [LinearOrder β] [NoMaxOrder β] {u : ℕ → β} (hu : Filter.Tendsto u Filter.atTop Filter.atTop)
Goal: ∃ᶠ (n : ℕ) in Filter.atTop, ∀ k < n, u k < u n
-- Filter.frequently_low_scores
theorem frequently_low_scores [LinearOrder β] [NoMinOrder β] {u : ℕ → β}
    (hu : Tendsto u atTop atBot) : ∃ᶠ n in atTop, ∀ k < n, u n < u k 
Arguments: {β : Type u_4} [LinearOrder β] [NoMinOrder β] {u : ℕ → β} (hu : Filter.Tendsto u Filter.atTop Filter.atBot)
Goal: ∃ᶠ (n : ℕ) in Filter.atTop, ∀ k < n, u n < u k
-- Filter.strictMono_subseq_of_tendsto_atTop
theorem strictMono_subseq_of_tendsto_atTop [LinearOrder β] [NoMaxOrder β] {u : ℕ → β}
    (hu : Tendsto u atTop atTop) : ∃ φ : ℕ → ℕ, StrictMono φ ∧ StrictMono (u ∘ φ) 
Arguments: {β : Type u_4} [LinearOrder β] [NoMaxOrder β] {u : ℕ → β} (hu : Filter.Tendsto u Filter.atTop Filter.atTop)
Goal: ∃ φ, StrictMono φ ∧ StrictMono (u ∘ φ)
-- Filter.strictMono_subseq_of_id_le
theorem strictMono_subseq_of_id_le {u : ℕ → ℕ} (hu : ∀ n, n ≤ u n) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ StrictMono (u ∘ φ) 
Arguments: {u : ℕ → ℕ} (hu : ∀ (n : ℕ), n ≤ u n)
Goal: ∃ φ, StrictMono φ ∧ StrictMono (u ∘ φ)
-- StrictMono.tendsto_atTop
theorem _root_.StrictMono.tendsto_atTop {φ : ℕ → ℕ} (h : StrictMono φ) : Tendsto φ atTop atTop 
Arguments: {φ : ℕ → ℕ} (h : StrictMono φ)
Goal: Filter.Tendsto φ Filter.atTop Filter.atTop
-- Filter.tendsto_atTop_add_nonneg_left'
theorem tendsto_atTop_add_nonneg_left' (hf : ∀ᶠ x in l, 0 ≤ f x) (hg : Tendsto g l atTop) :
    Tendsto (fun x => f x + g x) l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f g : α → β} (hf : ∀ᶠ (x : α) in l, 0 ≤ f x) (hg : Filter.Tendsto g l Filter.atTop)
Goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop
-- Filter.tendsto_atBot_add_nonpos_left'
theorem tendsto_atBot_add_nonpos_left' (hf : ∀ᶠ x in l, f x ≤ 0) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x + g x) l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f g : α → β} (hf : ∀ᶠ (x : α) in l, f x ≤ 0) (hg : Filter.Tendsto g l Filter.atBot)
Goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot
-- Filter.tendsto_atTop_add_nonneg_left
theorem tendsto_atTop_add_nonneg_left (hf : ∀ x, 0 ≤ f x) (hg : Tendsto g l atTop) :
    Tendsto (fun x => f x + g x) l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f g : α → β} (hf : ∀ (x : α), 0 ≤ f x) (hg : Filter.Tendsto g l Filter.atTop)
Goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop
-- Filter.tendsto_atBot_add_nonpos_left
theorem tendsto_atBot_add_nonpos_left (hf : ∀ x, f x ≤ 0) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x + g x) l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f g : α → β} (hf : ∀ (x : α), f x ≤ 0) (hg : Filter.Tendsto g l Filter.atBot)
Goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot
-- Filter.tendsto_atTop_add_nonneg_right'
theorem tendsto_atTop_add_nonneg_right' (hf : Tendsto f l atTop) (hg : ∀ᶠ x in l, 0 ≤ g x) :
    Tendsto (fun x => f x + g x) l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f g : α → β} (hf : Filter.Tendsto f l Filter.atTop) (hg : ∀ᶠ (x : α) in l, 0 ≤ g x)
Goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop
-- Filter.tendsto_atBot_add_nonpos_right'
theorem tendsto_atBot_add_nonpos_right' (hf : Tendsto f l atBot) (hg : ∀ᶠ x in l, g x ≤ 0) :
    Tendsto (fun x => f x + g x) l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f g : α → β} (hf : Filter.Tendsto f l Filter.atBot) (hg : ∀ᶠ (x : α) in l, g x ≤ 0)
Goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot
-- Filter.tendsto_atTop_add_nonneg_right
theorem tendsto_atTop_add_nonneg_right (hf : Tendsto f l atTop) (hg : ∀ x, 0 ≤ g x) :
    Tendsto (fun x => f x + g x) l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f g : α → β} (hf : Filter.Tendsto f l Filter.atTop) (hg : ∀ (x : α), 0 ≤ g x)
Goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop
-- Filter.tendsto_atBot_add_nonpos_right
theorem tendsto_atBot_add_nonpos_right (hf : Tendsto f l atBot) (hg : ∀ x, g x ≤ 0) :
    Tendsto (fun x => f x + g x) l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f g : α → β} (hf : Filter.Tendsto f l Filter.atBot) (hg : ∀ (x : α), g x ≤ 0)
Goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot
-- Filter.tendsto_atTop_add
theorem tendsto_atTop_add (hf : Tendsto f l atTop) (hg : Tendsto g l atTop) :
    Tendsto (fun x => f x + g x) l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f g : α → β} (hf : Filter.Tendsto f l Filter.atTop) (hg : Filter.Tendsto g l Filter.atTop)
Goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop
-- Filter.tendsto_atBot_add
theorem tendsto_atBot_add (hf : Tendsto f l atBot) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x + g x) l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f g : α → β} (hf : Filter.Tendsto f l Filter.atBot) (hg : Filter.Tendsto g l Filter.atBot)
Goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot
-- Filter.Tendsto.nsmul_atTop
theorem Tendsto.nsmul_atTop (hf : Tendsto f l atTop) {n : ℕ} (hn : 0 < n) :
    Tendsto (fun x => n • f x) l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f : α → β} (hf : Filter.Tendsto f l Filter.atTop) {n : ℕ} (hn : 0 < n)
Goal: Filter.Tendsto (fun x => n • f x) l Filter.atTop
-- Filter.Tendsto.nsmul_atBot
theorem Tendsto.nsmul_atBot (hf : Tendsto f l atBot) {n : ℕ} (hn : 0 < n) :
    Tendsto (fun x => n • f x) l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedAddCommMonoid β] {l : Filter α} {f : α → β} (hf : Filter.Tendsto f l Filter.atBot) {n : ℕ} (hn : 0 < n)
Goal: Filter.Tendsto (fun x => n • f x) l Filter.atBot
-- Filter.tendsto_atTop_of_add_const_left
theorem tendsto_atTop_of_add_const_left (C : β) (hf : Tendsto (fun x => C + f x) l atTop) :
    Tendsto f l atTop 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedCancelAddCommMonoid β] {l : Filter α} {f : α → β} (C : β) (hf : Filter.Tendsto (fun x => C + f x) l Filter.atTop)
Goal: Filter.Tendsto f l Filter.atTop
-- Filter.tendsto_atBot_of_add_const_left
theorem tendsto_atBot_of_add_const_left (C : β) (hf : Tendsto (fun x => C + f x) l atBot) :
    Tendsto f l atBot 
Arguments: {α : Type u_3} {β : Type u_4} [OrderedCancelAddCommMonoid β] {l : Filter α} {f : α → β} (C : β) (hf : Filter.Tendsto (fun x => C + f x) l Filter.atBot)
Goal: Filter.Tendsto f l Filter.atBot