Basic results on Filter.atTop and Filter.atBot filters

In this file we prove many lemmas like “if f → +∞, then f ± c → +∞”.

theorem Filter.hasAntitoneBasis_atTop {α : Type u_3} [Preorder α] [IsDirectedOrder α] [Nonempty α] : atTop.HasAntitoneBasis Set.Ici

theorem Filter.atTop_basis {α : Type u_3} [Preorder α] [IsDirectedOrder α] [Nonempty α] : atTop.HasBasis (fun (x : α) => True) Set.Ici

theorem Filter.atBot_basis {α : Type u_5} [Preorder α] [IsCodirectedOrder α] [Nonempty α] : atBot.HasBasis (fun (x : α) => True) Set.Iic

theorem Filter.atTop_basis_Ioi {α : Type u_3} [Preorder α] [IsDirectedOrder α] [Nonempty α] [NoMaxOrder α] : atTop.HasBasis (fun (x : α) => True) Set.Ioi

theorem Filter.atBot_basis_Iio {α : Type u_3} [Preorder α] [IsCodirectedOrder α] [Nonempty α] [NoMinOrder α] : atBot.HasBasis (fun (x : α) => True) Set.Iio

theorem Filter.atTop_basis_Ioi' {α : Type u_3} [Preorder α] [IsDirectedOrder α] [NoMaxOrder α] (a : α) : atTop.HasBasis (fun (x : α) => a < x) Set.Ioi

theorem Filter.atBot_basis_Iio' {α : Type u_3} [Preorder α] [IsCodirectedOrder α] [NoMinOrder α] (a : α) : atBot.HasBasis (fun (x : α) => x < a) Set.Iio

theorem Filter.atTop_basis' {α : Type u_3} [Preorder α] [IsDirectedOrder α] (a : α) : atTop.HasBasis (fun (x : α) => a ≤ x) Set.Ici

theorem Filter.atBot_basis' {α : Type u_3} [Preorder α] [IsCodirectedOrder α] (a : α) : atBot.HasBasis (fun (x : α) => x ≤ a) Set.Iic

instance Filter.atTop_neBot {α : Type u_3} [Preorder α] [IsDirectedOrder α] [Nonempty α] : atTop.NeBot

instance Filter.atBot_neBot {α : Type u_3} [Preorder α] [IsCodirectedOrder α] [Nonempty α] : atBot.NeBot

theorem Filter.atTop_neBot_iff {α : Type u_5} [Preorder α] : atTop.NeBot ↔ Nonempty α ∧ IsDirectedOrder α

theorem Filter.atBot_neBot_iff {α : Type u_5} [Preorder α] : atBot.NeBot ↔ Nonempty α ∧ IsCodirectedOrder α

@[simp]

theorem Filter.mem_atTop_sets {α : Type u_3} [Preorder α] [IsDirectedOrder α] [Nonempty α] {s : Set α} : s ∈ atTop ↔ ∃ (a : α), ∀ (b : α), a ≤ b → b ∈ s

@[simp]

theorem Filter.mem_atBot_sets {α : Type u_3} [Preorder α] [IsCodirectedOrder α] [Nonempty α] {s : Set α} : s ∈ atBot ↔ ∃ (a : α), ∀ b ≤ a, b ∈ s

@[simp]

theorem Filter.eventually_atTop {α : Type u_3} [Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α] : (∀ᶠ (x : α) in atTop, p x) ↔ ∃ (a : α), ∀ (b : α), a ≤ b → p b

@[simp]

theorem Filter.eventually_atBot {α : Type u_3} [Preorder α] [IsCodirectedOrder α] {p : α → Prop} [Nonempty α] : (∀ᶠ (x : α) in atBot, p x) ↔ ∃ (a : α), ∀ b ≤ a, p b

theorem Filter.frequently_atTop {α : Type u_3} [Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α] : (∃ᶠ (x : α) in atTop, p x) ↔ ∀ (a : α), ∃ (b : α), a ≤ b ∧ p b

theorem Filter.frequently_atBot {α : Type u_3} [Preorder α] [IsCodirectedOrder α] {p : α → Prop} [Nonempty α] : (∃ᶠ (x : α) in atBot, p x) ↔ ∀ (a : α), ∃ b ≤ a, p b

theorem Filter.Eventually.exists_forall_of_atTop {α : Type u_3} [Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α] : (∀ᶠ (x : α) in atTop, p x) → ∃ (a : α), ∀ (b : α), a ≤ b → p b

Alias of the forward direction of Filter.eventually_atTop.

theorem Filter.Eventually.exists_forall_of_atBot {α : Type u_3} [Preorder α] [IsCodirectedOrder α] {p : α → Prop} [Nonempty α] : (∀ᶠ (x : α) in atBot, p x) → ∃ (a : α), ∀ b ≤ a, p b

Alias of the forward direction of Filter.eventually_atBot.

theorem Filter.exists_eventually_atTop {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] [Nonempty α] {r : α → β → Prop} : (∃ (b : β), ∀ᶠ (a : α) in atTop, r a b) ↔ ∀ᶠ (a₀ : α) in atTop, ∃ (b : β), ∀ (a : α), a₀ ≤ a → r a b

theorem Filter.exists_eventually_atBot {β : Type u_4} {α : Type u_5} [Preorder α] [IsCodirectedOrder α] [Nonempty α] {r : α → β → Prop} : (∃ (b : β), ∀ᶠ (a : α) in atBot, r a b) ↔ ∀ᶠ (a₀ : α) in atBot, ∃ (b : β), ∀ a ≤ a₀, r a b

theorem Filter.map_atTop_eq {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] [Nonempty α] {f : α → β} : map f atTop = ⨅ (a : α), principal (f '' {a' : α | a ≤ a'})

theorem Filter.map_atBot_eq {α : Type u_3} {β : Type u_4} [Preorder α] [IsCodirectedOrder α] [Nonempty α] {f : α → β} : map f atBot = ⨅ (a : α), principal (f '' {a' : α | a' ≤ a})

theorem Filter.frequently_atTop' {α : Type u_3} [Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α] [NoMaxOrder α] : (∃ᶠ (x : α) in atTop, p x) ↔ ∀ (a : α), ∃ b > a, p b

theorem Filter.frequently_atBot' {α : Type u_3} [Preorder α] [IsCodirectedOrder α] {p : α → Prop} [Nonempty α] [NoMinOrder α] : (∃ᶠ (x : α) in atBot, p x) ↔ ∀ (a : α), ∃ (b : α), a > b ∧ p b

Sequences

theorem Filter.extraction_of_frequently_atTop {P : ℕ → Prop} (h : ∃ᶠ (n : ℕ) in atTop, P n) : ∃ (φ : ℕ → ℕ), StrictMono φ ∧ ∀ (n : ℕ), P (φ n)

theorem Filter.extraction_of_eventually_atTop {P : ℕ → Prop} (h : ∀ᶠ (n : ℕ) in atTop, P n) : ∃ (φ : ℕ → ℕ), StrictMono φ ∧ ∀ (n : ℕ), P (φ n)

theorem Filter.extraction_forall_of_frequently {P : ℕ → ℕ → Prop} (h : ∀ (n : ℕ), ∃ᶠ (k : ℕ) in atTop, P n k) : ∃ (φ : ℕ → ℕ), StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)

theorem Filter.extraction_forall_of_eventually {P : ℕ → ℕ → Prop} (h : ∀ (n : ℕ), ∀ᶠ (k : ℕ) in atTop, P n k) : ∃ (φ : ℕ → ℕ), StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)

theorem Filter.extraction_forall_of_eventually' {P : ℕ → ℕ → Prop} (h : ∀ (n : ℕ), ∃ (N : ℕ), ∀ k ≥ N, P n k) : ∃ (φ : ℕ → ℕ), StrictMono φ ∧ ∀ (n : ℕ), P n (φ n)

theorem Filter.inf_map_atTop_neBot_iff {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] {F : Filter β} {u : α → β} [Nonempty α] : (F ⊓ map u atTop).NeBot ↔ ∀ U ∈ F, ∀ (N : α), ∃ (n : α), N ≤ n ∧ u n ∈ U

theorem Filter.inf_map_atBot_neBot_iff {α : Type u_3} {β : Type u_4} [Preorder α] [IsCodirectedOrder α] {F : Filter β} {u : α → β} [Nonempty α] : (F ⊓ map u atBot).NeBot ↔ ∀ U ∈ F, ∀ (N : α), ∃ n ≤ N, u n ∈ U

theorem Filter.exists_le_of_tendsto_atTop {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] {u : α → β} [Preorder β] (h : Tendsto u atTop atTop) (a : α) (b : β) : ∃ (a' : α), a ≤ a' ∧ b ≤ u a'

theorem Filter.exists_le_of_tendsto_atBot {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] {u : α → β} [Preorder β] (h : Tendsto u atTop atBot) (a : α) (b : β) : ∃ (a' : α), a ≤ a' ∧ u a' ≤ b

theorem Filter.exists_lt_of_tendsto_atTop {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] {u : α → β} [Preorder β] [NoMaxOrder β] (h : Tendsto u atTop atTop) (a : α) (b : β) : ∃ (a' : α), a ≤ a' ∧ b < u a'

theorem Filter.exists_lt_of_tendsto_atBot {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] {u : α → β} [Preorder β] [NoMinOrder β] (h : Tendsto u atTop atBot) (a : α) (b : β) : ∃ (a' : α), a ≤ a' ∧ u a' < b

theorem Filter.tendsto_atTop' {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsDirectedOrder α] {f : α → β} {l : Filter β} : Tendsto f atTop l ↔ ∀ s ∈ l, ∃ (a : α), ∀ (b : α), a ≤ b → f b ∈ s

theorem Filter.tendsto_atBot' {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsCodirectedOrder α] {f : α → β} {l : Filter β} : Tendsto f atBot l ↔ ∀ s ∈ l, ∃ (a : α), ∀ b ≤ a, f b ∈ s

theorem Filter.tendsto_atTop_principal {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsDirectedOrder α] {f : α → β} {s : Set β} : Tendsto f atTop (principal s) ↔ ∃ (N : α), ∀ (n : α), N ≤ n → f n ∈ s

theorem Filter.tendsto_atBot_principal {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsCodirectedOrder α] {f : α → β} {s : Set β} : Tendsto f atBot (principal s) ↔ ∃ (N : α), ∀ n ≤ N, f n ∈ s

theorem Filter.tendsto_atTop_atTop {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsDirectedOrder α] {f : α → β} [Preorder β] : Tendsto f atTop atTop ↔ ∀ (b : β), ∃ (i : α), ∀ (a : α), i ≤ a → b ≤ f a

theorem Filter.tendsto_atBot_atBot {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsCodirectedOrder α] {f : α → β} [Preorder β] : Tendsto f atBot atBot ↔ ∀ (b : β), ∃ (i : α), ∀ a ≤ i, f a ≤ b

theorem Filter.tendsto_atTop_atBot {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsDirectedOrder α] {f : α → β} [Preorder β] : Tendsto f atTop atBot ↔ ∀ (b : β), ∃ (i : α), ∀ (a : α), i ≤ a → f a ≤ b

theorem Filter.tendsto_atBot_atTop {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsCodirectedOrder α] {f : α → β} [Preorder β] : Tendsto f atBot atTop ↔ ∀ (b : β), ∃ (i : α), ∀ a ≤ i, b ≤ f a

theorem Filter.tendsto_atTop_atTop_iff_of_monotone {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsDirectedOrder α] {f : α → β} [Preorder β] (hf : Monotone f) : Tendsto f atTop atTop ↔ ∀ (b : β), ∃ (a : α), b ≤ f a

theorem Filter.tendsto_atBot_atBot_iff_of_monotone {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsCodirectedOrder α] {f : α → β} [Preorder β] (hf : Monotone f) : Tendsto f atBot atBot ↔ ∀ (b : β), ∃ (a : α), f a ≤ b

theorem Monotone.tendsto_atTop_atTop_iff {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsDirectedOrder α] {f : α → β} [Preorder β] (hf : Monotone f) : Filter.Tendsto f Filter.atTop Filter.atTop ↔ ∀ (b : β), ∃ (a : α), b ≤ f a

Alias of Filter.tendsto_atTop_atTop_iff_of_monotone.

theorem Monotone.tendsto_atBot_atBot_iff {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsCodirectedOrder α] {f : α → β} [Preorder β] (hf : Monotone f) : Filter.Tendsto f Filter.atBot Filter.atBot ↔ ∀ (b : β), ∃ (a : α), f a ≤ b

Alias of Filter.tendsto_atBot_atBot_iff_of_monotone.

theorem Filter.tendsto_atTop_atBot_iff_of_antitone {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsDirectedOrder α] {f : α → β} [Preorder β] (hf : Antitone f) : Tendsto f atTop atBot ↔ ∀ (b : β), ∃ (a : α), f a ≤ b

theorem Filter.tendsto_atBot_atTop_iff_of_antitone {α : Type u_3} {β : Type u_4} [Nonempty α] [Preorder α] [IsCodirectedOrder α] {f : α → β} [Preorder β] (hf : Antitone f) : Tendsto f atBot atTop ↔ ∀ (b : β), ∃ (a : α), b ≤ f a

theorem Filter.Tendsto.subseq_mem {α : Type u_3} {F : Filter α} {V : ℕ → Set α} (h : ∀ (n : ℕ), V n ∈ F) {u : ℕ → α} (hu : Tendsto u atTop F) : ∃ (φ : ℕ → ℕ), StrictMono φ ∧ ∀ (n : ℕ), u (φ n) ∈ V n

theorem Filter.map_atTop_eq_of_gc_preorder {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] [Preorder β] [IsDirectedOrder β] {f : α → β} (hf : Monotone f) (b : β) (hgi : ∀ (c : β), b ≤ c → ∃ (x : α), f x = c ∧ ∀ (a : α), f a ≤ c ↔ a ≤ x) : map f atTop = atTop

A function f maps upwards closed sets (atTop sets) to upwards closed sets when it is a Galois insertion. The Galois "insertion" and "connection" is weakened to only require it to be an insertion and a connection above b.

theorem Filter.map_atBot_eq_of_gc_preorder {α : Type u_3} {β : Type u_4} [Preorder α] [IsCodirectedOrder α] [Preorder β] [IsCodirectedOrder β] {f : α → β} (hf : Monotone f) (b : β) (hgi : ∀ c ≤ b, ∃ (x : α), f x = c ∧ ∀ (a : α), c ≤ f a ↔ x ≤ a) : map f atBot = atBot

A function f maps downwards closed sets (atBot sets) to downwards closed sets when it is a Galois coinsertion. The Galois "coinsertion" and "connection" is weakened to only require it to be an insertion and a connection below b.

theorem Filter.map_atTop_eq_of_gc {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] [PartialOrder β] [IsDirectedOrder β] {f : α → β} (g : β → α) (b : β) (hf : Monotone f) (gc : ∀ (a : α) (c : β), b ≤ c → (f a ≤ c ↔ a ≤ g c)) (hgi : ∀ (c : β), b ≤ c → c ≤ f (g c)) : map f atTop = atTop

A function f maps upwards closed sets (atTop sets) to upwards closed sets when it is a Galois insertion. The Galois "insertion" and "connection" is weakened to only require it to be an insertion and a connection above b.

theorem Filter.map_atBot_eq_of_gc {α : Type u_3} {β : Type u_4} [Preorder α] [IsCodirectedOrder α] [PartialOrder β] [IsCodirectedOrder β] {f : α → β} (g : β → α) (b : β) (hf : Monotone f) (gc : ∀ (a : α), ∀ c ≤ b, c ≤ f a ↔ g c ≤ a) (hgi : ∀ c ≤ b, f (g c) ≤ c) : map f atBot = atBot

A function f maps downwards closed sets (atBot sets) to downwards closed sets when it is a Galois coinsertion. The Galois "coinsertion" and "connection" is weakened to only require it to be an insertion and a connection below b.

theorem Filter.map_val_atTop_of_Ici_subset {α : Type u_3} [Preorder α] [IsDirectedOrder α] {a : α} {s : Set α} (h : Set.Ici a ⊆ s) : map Subtype.val atTop = atTop

theorem Filter.map_val_atBot_of_Iic_subset {α : Type u_3} [Preorder α] [IsCodirectedOrder α] {a : α} {s : Set α} (h : Set.Iic a ⊆ s) : map Subtype.val atBot = atBot

@[simp]

theorem Nat.map_cast_int_atTop : Filter.map Nat.cast Filter.atTop = Filter.atTop

@[simp]

theorem Filter.map_val_Ici_atTop {α : Type u_3} [Preorder α] [IsDirectedOrder α] (a : α) : map Subtype.val atTop = atTop

The image of the filter atTop on Ici a under the coercion equals atTop.

@[simp]

theorem Filter.map_val_Iic_atBot {α : Type u_3} [Preorder α] [IsCodirectedOrder α] (a : α) : map Subtype.val atBot = atBot

The image of the filter atBot on Iic a under the coercion equals atBot.

@[simp]

theorem Filter.map_val_Ioi_atTop {α : Type u_3} [Preorder α] [IsDirectedOrder α] [NoMaxOrder α] (a : α) : map Subtype.val atTop = atTop

The image of the filter atTop on Ioi a under the coercion equals atTop.

@[simp]

theorem Filter.map_val_Iio_atBot {α : Type u_3} [Preorder α] [IsCodirectedOrder α] [NoMinOrder α] (a : α) : map Subtype.val atBot = atBot

The image of the filter atBot on Iio a under the coercion equals atBot.

theorem Filter.atTop_Ioi_eq {α : Type u_3} [Preorder α] [IsDirectedOrder α] (a : α) : atTop = comap Subtype.val atTop

The atTop filter for ↑(Ioi a) comes from the atTop filter in the ambient order.

theorem Filter.atBot_Iio_eq {α : Type u_3} [Preorder α] [IsCodirectedOrder α] (a : α) : atBot = comap Subtype.val atBot

The atBot filter for ↑(Iio a) comes from the atBot filter in the ambient order.

theorem Filter.atTop_Ici_eq {α : Type u_3} [Preorder α] [IsDirectedOrder α] (a : α) : atTop = comap Subtype.val atTop

The atTop filter for ↑(Ici a) comes from the atTop filter in the ambient order.

theorem Filter.atBot_Iic_eq {α : Type u_3} [Preorder α] [IsCodirectedOrder α] (a : α) : atBot = comap Subtype.val atBot

The atBot filter for ↑(Iic a) comes from the atBot filter in the ambient order.

theorem Filter.tendsto_Ioi_atTop {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] {a : α} {f : β → ↑(Set.Ioi a)} {l : Filter β} : Tendsto f l atTop ↔ Tendsto (fun (x : β) => ↑(f x)) l atTop

theorem Filter.tendsto_Iio_atBot {α : Type u_3} {β : Type u_4} [Preorder α] [IsCodirectedOrder α] {a : α} {f : β → ↑(Set.Iio a)} {l : Filter β} : Tendsto f l atBot ↔ Tendsto (fun (x : β) => ↑(f x)) l atBot

theorem Filter.tendsto_Ici_atTop {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] {a : α} {f : β → ↑(Set.Ici a)} {l : Filter β} : Tendsto f l atTop ↔ Tendsto (fun (x : β) => ↑(f x)) l atTop

theorem Filter.tendsto_Iic_atBot {α : Type u_3} {β : Type u_4} [Preorder α] [IsCodirectedOrder α] {a : α} {f : β → ↑(Set.Iic a)} {l : Filter β} : Tendsto f l atBot ↔ Tendsto (fun (x : β) => ↑(f x)) l atBot

@[simp]

theorem Filter.tendsto_comp_val_Ioi_atTop {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] [NoMaxOrder α] {a : α} {f : α → β} {l : Filter β} : Tendsto (fun (x : ↑(Set.Ioi a)) => f ↑x) atTop l ↔ Tendsto f atTop l

@[simp]

theorem Filter.tendsto_comp_val_Iio_atBot {α : Type u_3} {β : Type u_4} [Preorder α] [IsCodirectedOrder α] [NoMinOrder α] {a : α} {f : α → β} {l : Filter β} : Tendsto (fun (x : ↑(Set.Iio a)) => f ↑x) atBot l ↔ Tendsto f atBot l

@[simp]

theorem Filter.tendsto_comp_val_Ici_atTop {α : Type u_3} {β : Type u_4} [Preorder α] [IsDirectedOrder α] {a : α} {f : α → β} {l : Filter β} : Tendsto (fun (x : ↑(Set.Ici a)) => f ↑x) atTop l ↔ Tendsto f atTop l

@[simp]

theorem Filter.tendsto_comp_val_Iic_atBot {α : Type u_3} {β : Type u_4} [Preorder α] [IsCodirectedOrder α] {a : α} {f : α → β} {l : Filter β} : Tendsto (fun (x : ↑(Set.Iic a)) => f ↑x) atBot l ↔ Tendsto f atBot l

theorem Filter.map_add_atTop_eq_nat (k : ℕ) : map (fun (a : ℕ) => a + k) atTop = atTop

theorem Filter.map_sub_atTop_eq_nat (k : ℕ) : map (fun (a : ℕ) => a - k) atTop = atTop

theorem Filter.tendsto_add_atTop_nat (k : ℕ) : Tendsto (fun (a : ℕ) => a + k) atTop atTop

theorem Filter.tendsto_sub_atTop_nat (k : ℕ) : Tendsto (fun (a : ℕ) => a - k) atTop atTop

theorem Filter.tendsto_add_atTop_iff_nat {α : Type u_3} {f : ℕ → α} {l : Filter α} (k : ℕ) : Tendsto (fun (n : ℕ) => f (n + k)) atTop l ↔ Tendsto f atTop l

theorem Filter.map_div_atTop_eq_nat (k : ℕ) (hk : 0 < k) : map (fun (a : ℕ) => a / k) atTop = atTop

theorem Filter.tendsto_inf_atTop {α : Type u_5} {β : Type u_6} [SemilatticeInf α] {f g : β → α} (F : Filter β) (hf : Tendsto f F atTop) (hg : Tendsto g F atTop) : Tendsto (fun (x : β) => f x ⊓ g x) F atTop

theorem Filter.tendsto_sup_atBot {α : Type u_5} {β : Type u_6} [SemilatticeSup α] {f g : β → α} (F : Filter β) (hf : Tendsto f F atBot) (hg : Tendsto g F atBot) : Tendsto (fun (x : β) => f x ⊔ g x) F atBot

theorem Filter.not_bddAbove_of_tendsto_atTop {α : Type u_3} {β : Type u_4} [Preorder β] {l : Filter α} [l.NeBot] {f : α → β} [NoMaxOrder β] (h : Tendsto f l atTop) : ¬BddAbove (Set.range f)

theorem Filter.not_bddBelow_of_tendsto_atBot {α : Type u_3} {β : Type u_4} [Preorder β] {l : Filter α} [l.NeBot] {f : α → β} [NoMinOrder β] (h : Tendsto f l atBot) : ¬BddBelow (Set.range f)

theorem Filter.HasAntitoneBasis.eventually_subset {ι : Type u_1} {α : Type u_3} [Preorder ι] {l : Filter α} {s : ι → Set α} (hl : l.HasAntitoneBasis s) {t : Set α} (ht : t ∈ l) : ∀ᶠ (i : ι) in atTop, s i ⊆ t

theorem Filter.HasAntitoneBasis.tendsto {ι : Type u_1} {α : Type u_3} [Preorder ι] {l : Filter α} {s : ι → Set α} (hl : l.HasAntitoneBasis s) {φ : ι → α} (h : ∀ (i : ι), φ i ∈ s i) : Tendsto φ atTop l

theorem Filter.HasAntitoneBasis.comp_mono {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [Nonempty ι] [Preorder ι] [IsDirectedOrder ι] [Preorder ι'] {l : Filter α} {s : ι' → Set α} (hs : l.HasAntitoneBasis s) {φ : ι → ι'} (φ_mono : Monotone φ) (hφ : Tendsto φ atTop atTop) : l.HasAntitoneBasis (s ∘ φ)

theorem Filter.HasAntitoneBasis.comp_strictMono {α : Type u_3} {l : Filter α} {s : ℕ → Set α} (hs : l.HasAntitoneBasis s) {φ : ℕ → ℕ} (hφ : StrictMono φ) : l.HasAntitoneBasis (s ∘ φ)

theorem Filter.subseq_forall_of_frequently {ι : Type u_5} {x : ℕ → ι} {p : ι → Prop} {l : Filter ι} (h_tendsto : Tendsto x atTop l) (h : ∃ᶠ (n : ℕ) in atTop, p (x n)) : ∃ (ns : ℕ → ℕ), Tendsto (fun (n : ℕ) => x (ns n)) atTop l ∧ ∀ (n : ℕ), p (x (ns n))