mathlibdocumentation

order.filter.at_top_bot

at_top and at_bot filters on preorded sets, monoids and groups. #

In this file we define the filters

• at_top: corresponds to n → +∞;
• at_bot: corresponds to n → -∞.

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

def filter.at_top {α : Type u_3} [preorder α] :

at_top is the filter representing the limit → ∞ on an ordered set. It is generated by the collection of up-sets {b | a ≤ b}. (The preorder need not have a top element for this to be well defined, and indeed is trivial when a top element exists.)

Equations
def filter.at_bot {α : Type u_3} [preorder α] :

at_bot is the filter representing the limit → -∞ on an ordered set. It is generated by the collection of down-sets {b | b ≤ a}. (The preorder need not have a bottom element for this to be well defined, and indeed is trivial when a bottom element exists.)

Equations
theorem filter.mem_at_top {α : Type u_3} [preorder α] (a : α) :
{b : α | a b} filter.at_top
theorem filter.Ioi_mem_at_top {α : Type u_3} [preorder α] [no_max_order α] (x : α) :
theorem filter.mem_at_bot {α : Type u_3} [preorder α] (a : α) :
{b : α | b a} filter.at_bot
theorem filter.Iio_mem_at_bot {α : Type u_3} [preorder α] [no_min_order α] (x : α) :
theorem filter.at_top_basis {α : Type u_3} [nonempty α]  :
theorem filter.at_top_basis' {α : Type u_3} (a : α) :
filter.at_top.has_basis (λ (x : α), a x) set.Ici
theorem filter.at_bot_basis {α : Type u_3} [nonempty α]  :
theorem filter.at_bot_basis' {α : Type u_3} (a : α) :
filter.at_bot.has_basis (λ (x : α), x a) set.Iic
@[instance]
theorem filter.at_top_ne_bot {α : Type u_3} [nonempty α]  :
@[instance]
theorem filter.at_bot_ne_bot {α : Type u_3} [nonempty α]  :
@[simp]
theorem filter.mem_at_top_sets {α : Type u_3} [nonempty α] {s : set α} :
∃ (a : α), ∀ (b : α), b ab s
@[simp]
theorem filter.mem_at_bot_sets {α : Type u_3} [nonempty α] {s : set α} :
∃ (a : α), ∀ (b : α), b ab s
@[simp]
theorem filter.eventually_at_top {α : Type u_3} [nonempty α] {p : α → Prop} :
(∀ᶠ (x : α) in filter.at_top, p x) ∃ (a : α), ∀ (b : α), b ap b
@[simp]
theorem filter.eventually_at_bot {α : Type u_3} [nonempty α] {p : α → Prop} :
(∀ᶠ (x : α) in filter.at_bot, p x) ∃ (a : α), ∀ (b : α), b ap b
theorem filter.eventually_ge_at_top {α : Type u_3} [preorder α] (a : α) :
∀ᶠ (x : α) in filter.at_top, a x
theorem filter.eventually_le_at_bot {α : Type u_3} [preorder α] (a : α) :
∀ᶠ (x : α) in filter.at_bot, x a
theorem filter.eventually_gt_at_top {α : Type u_3} [preorder α] [no_max_order α] (a : α) :
∀ᶠ (x : α) in filter.at_top, a < x
theorem filter.eventually_ne_at_top {α : Type u_3} [preorder α] [no_max_order α] (a : α) :
∀ᶠ (x : α) in filter.at_top, x a
theorem filter.eventually_lt_at_bot {α : Type u_3} [preorder α] [no_min_order α] (a : α) :
∀ᶠ (x : α) in filter.at_bot, x < a
theorem filter.at_top_basis_Ioi {α : Type u_3} [nonempty α] [no_max_order α] :
@[protected, instance]
def filter.at_top.is_countably_generated {α : Type u_3} [preorder α] [encodable α] :
@[protected, instance]
def filter.at_bot.is_countably_generated {α : Type u_3} [preorder α] [encodable α] :
theorem filter.order_top.at_top_eq (α : Type u_1) [order_top α] :
theorem filter.order_bot.at_bot_eq (α : Type u_1) [order_bot α] :
theorem filter.subsingleton.at_top_eq (α : Type u_1) [subsingleton α] [preorder α] :
theorem filter.subsingleton.at_bot_eq (α : Type u_1) [subsingleton α] [preorder α] :
theorem filter.tendsto_at_top_pure {α : Type u_3} {β : Type u_4} [order_top α] (f : α → β) :
(pure (f ))
theorem filter.tendsto_at_bot_pure {α : Type u_3} {β : Type u_4} [order_bot α] (f : α → β) :
(pure (f ))
theorem filter.eventually.exists_forall_of_at_top {α : Type u_3} [nonempty α] {p : α → Prop} (h : ∀ᶠ (x : α) in filter.at_top, p x) :
∃ (a : α), ∀ (b : α), b ap b
theorem filter.eventually.exists_forall_of_at_bot {α : Type u_3} [nonempty α] {p : α → Prop} (h : ∀ᶠ (x : α) in filter.at_bot, p x) :
∃ (a : α), ∀ (b : α), b ap b
theorem filter.frequently_at_top {α : Type u_3} [nonempty α] {p : α → Prop} :
(∃ᶠ (x : α) in filter.at_top, p x) ∀ (a : α), ∃ (b : α) (H : b a), p b
theorem filter.frequently_at_bot {α : Type u_3} [nonempty α] {p : α → Prop} :
(∃ᶠ (x : α) in filter.at_bot, p x) ∀ (a : α), ∃ (b : α) (H : b a), p b
theorem filter.frequently_at_top' {α : Type u_3} [nonempty α] [no_max_order α] {p : α → Prop} :
(∃ᶠ (x : α) in filter.at_top, p x) ∀ (a : α), ∃ (b : α) (H : b > a), p b
theorem filter.frequently_at_bot' {α : Type u_3} [nonempty α] [no_min_order α] {p : α → Prop} :
(∃ᶠ (x : α) in filter.at_bot, p x) ∀ (a : α), ∃ (b : α) (H : b < a), p b
theorem filter.frequently.forall_exists_of_at_top {α : Type u_3} [nonempty α] {p : α → Prop} (h : ∃ᶠ (x : α) in filter.at_top, p x) (a : α) :
∃ (b : α) (H : b a), p b
theorem filter.frequently.forall_exists_of_at_bot {α : Type u_3} [nonempty α] {p : α → Prop} (h : ∃ᶠ (x : α) in filter.at_bot, p x) (a : α) :
∃ (b : α) (H : b a), p b
theorem filter.map_at_top_eq {α : Type u_3} {β : Type u_4} [nonempty α] {f : α → β} :
= ⨅ (a : α), 𝓟 (f '' {a' : α | a a'})
theorem filter.map_at_bot_eq {α : Type u_3} {β : Type u_4} [nonempty α] {f : α → β} :
= ⨅ (a : α), 𝓟 (f '' {a' : α | a' a})
theorem filter.tendsto_at_top {α : Type u_3} {β : Type u_4} [preorder β] {m : α → β} {f : filter α} :
∀ (b : β), ∀ᶠ (a : α) in f, b m a
theorem filter.tendsto_at_bot {α : Type u_3} {β : Type u_4} [preorder β] {m : α → β} {f : filter α} :
∀ (b : β), ∀ᶠ (a : α) in f, m a b
theorem filter.tendsto_at_top_mono' {α : Type u_3} {β : Type u_4} [preorder β] (l : filter α) ⦃f₁ f₂ : α → β⦄ (h : f₁ ≤ᶠ[l] f₂) :
theorem filter.tendsto_at_bot_mono' {α : Type u_3} {β : Type u_4} [preorder β] (l : filter α) ⦃f₁ f₂ : α → β⦄ (h : f₁ ≤ᶠ[l] f₂) :
theorem filter.tendsto_at_top_mono {α : Type u_3} {β : Type u_4} [preorder β] {l : filter α} {f g : α → β} (h : ∀ (n : α), f n g n) :
theorem filter.tendsto_at_bot_mono {α : Type u_3} {β : Type u_4} [preorder β] {l : filter α} {f g : α → β} (h : ∀ (n : α), f n g n) :

Sequences #

theorem filter.inf_map_at_top_ne_bot_iff {α : Type u_3} {β : Type u_4} [nonempty α] {F : filter β} {u : α → β} :
(F .ne_bot ∀ (U : set β), U F∀ (N : α), ∃ (n : α) (H : n N), u n U
theorem filter.inf_map_at_bot_ne_bot_iff {α : Type u_3} {β : Type u_4} [nonempty α] {F : filter β} {u : α → β} :
(F .ne_bot ∀ (U : set β), U F∀ (N : α), ∃ (n : α) (H : n N), u n U
theorem filter.extraction_of_frequently_at_top' {P : → Prop} (h : ∀ (N : ), ∃ (n : ) (H : n > N), P n) :
∃ (φ : ), ∀ (n : ), P (φ n)
theorem filter.extraction_of_frequently_at_top {P : → Prop} (h : ∃ᶠ (n : ) in filter.at_top, P n) :
∃ (φ : ), ∀ (n : ), P (φ n)
theorem filter.extraction_of_eventually_at_top {P : → Prop} (h : ∀ᶠ (n : ) in filter.at_top, P n) :
∃ (φ : ), ∀ (n : ), P (φ n)
theorem filter.extraction_forall_of_frequently {P : → Prop} (h : ∀ (n : ), ∃ᶠ (k : ) in filter.at_top, P n k) :
∃ (φ : ), ∀ (n : ), P n (φ n)
theorem filter.extraction_forall_of_eventually {P : → Prop} (h : ∀ (n : ), ∀ᶠ (k : ) in filter.at_top, P n k) :
∃ (φ : ), ∀ (n : ), P n (φ n)
theorem filter.extraction_forall_of_eventually' {P : → Prop} (h : ∀ (n : ), ∃ (N : ), ∀ (k : ), k NP n k) :
∃ (φ : ), ∀ (n : ), P n (φ n)
theorem filter.exists_le_of_tendsto_at_top {α : Type u_3} {β : Type u_4} [preorder β] {u : α → β} (a : α) (b : β) :
∃ (a' : α) (H : a' a), b u a'
@[nolint]
theorem filter.exists_le_of_tendsto_at_bot {α : Type u_3} {β : Type u_4} [preorder β] {u : α → β} (a : α) (b : β) :
∃ (a' : α) (H : a' a), u a' b
theorem filter.exists_lt_of_tendsto_at_top {α : Type u_3} {β : Type u_4} [preorder β] [no_max_order β] {u : α → β} (a : α) (b : β) :
∃ (a' : α) (H : a' a), b < u a'
@[nolint]
theorem filter.exists_lt_of_tendsto_at_bot {α : Type u_3} {β : Type u_4} [preorder β] [no_min_order β] {u : α → β} (a : α) (b : β) :
∃ (a' : α) (H : a' a), u a' < b
theorem filter.high_scores {β : Type u_4} [linear_order β] [no_max_order β] {u : → β} (N : ) :
∃ (n : ) (H : n N), ∀ (k : ), k < nu k < u n

If u is a sequence which is unbounded above, then after any point, it reaches a value strictly greater than all previous values.

@[nolint]
theorem filter.low_scores {β : Type u_4} [linear_order β] [no_min_order β] {u : → β} (N : ) :
∃ (n : ) (H : n N), ∀ (k : ), k < nu n < u k

If u is a sequence which is unbounded below, then after any point, it reaches a value strictly smaller than all previous values.

theorem filter.frequently_high_scores {β : Type u_4} [linear_order β] [no_max_order β] {u : → β}  :
∃ᶠ (n : ) in filter.at_top, ∀ (k : ), k < nu k < u n

If u is a sequence which is unbounded above, then it frequently reaches a value strictly greater than all previous values.

theorem filter.frequently_low_scores {β : Type u_4} [linear_order β] [no_min_order β] {u : → β}  :
∃ᶠ (n : ) in filter.at_top, ∀ (k : ), k < nu n < u k

If u is a sequence which is unbounded below, then it frequently reaches a value strictly smaller than all previous values.

theorem filter.strict_mono_subseq_of_tendsto_at_top {β : Type u_1} [linear_order β] [no_max_order β] {u : → β}  :
∃ (φ : ), strict_mono (u φ)
theorem filter.strict_mono_subseq_of_id_le {u : } (hu : ∀ (n : ), n u n) :
∃ (φ : ), strict_mono (u φ)
theorem strict_mono.tendsto_at_top {φ : } (h : strict_mono φ) :
theorem filter.tendsto_at_top_add_nonneg_left' {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (hf : ∀ᶠ (x : α) in l, 0 f x) (hg : filter.at_top) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_add_nonpos_left' {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (hf : ∀ᶠ (x : α) in l, f x 0) (hg : filter.at_bot) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto_at_top_add_nonneg_left {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (hf : ∀ (x : α), 0 f x) (hg : filter.at_top) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_add_nonpos_left {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (hf : ∀ (x : α), f x 0) (hg : filter.at_bot) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto_at_top_add_nonneg_right' {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (hf : filter.at_top) (hg : ∀ᶠ (x : α) in l, 0 g x) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_add_nonpos_right' {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (hf : filter.at_bot) (hg : ∀ᶠ (x : α) in l, g x 0) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto_at_top_add_nonneg_right {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (hf : filter.at_top) (hg : ∀ (x : α), 0 g x) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_add_nonpos_right {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (hf : filter.at_bot) (hg : ∀ (x : α), g x 0) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto_at_top_add {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (hf : filter.at_top) (hg : filter.at_top) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_add {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (hf : filter.at_bot) (hg : filter.at_bot) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto.nsmul_at_top {α : Type u_3} {β : Type u_4} {l : filter α} {f : α → β} (hf : filter.at_top) {n : } (hn : 0 < n) :
filter.tendsto (λ (x : α), n f x) l filter.at_top
theorem filter.tendsto.nsmul_at_bot {α : Type u_3} {β : Type u_4} {l : filter α} {f : α → β} (hf : filter.at_bot) {n : } (hn : 0 < n) :
filter.tendsto (λ (x : α), n f x) l filter.at_bot
theorem filter.tendsto_bit0_at_top {β : Type u_4}  :
theorem filter.tendsto_bit0_at_bot {β : Type u_4}  :
theorem filter.tendsto_at_top_of_add_const_left {α : Type u_3} {β : Type u_4} {l : filter α} {f : α → β} (C : β) (hf : filter.tendsto (λ (x : α), C + f x) l filter.at_top) :
theorem filter.tendsto_at_bot_of_add_const_left {α : Type u_3} {β : Type u_4} {l : filter α} {f : α → β} (C : β) (hf : filter.tendsto (λ (x : α), C + f x) l filter.at_bot) :
theorem filter.tendsto_at_top_of_add_const_right {α : Type u_3} {β : Type u_4} {l : filter α} {f : α → β} (C : β) (hf : filter.tendsto (λ (x : α), f x + C) l filter.at_top) :
theorem filter.tendsto_at_bot_of_add_const_right {α : Type u_3} {β : Type u_4} {l : filter α} {f : α → β} (C : β) (hf : filter.tendsto (λ (x : α), f x + C) l filter.at_bot) :
theorem filter.tendsto_at_top_of_add_bdd_above_left' {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (C : β) (hC : ∀ᶠ (x : α) in l, f x C) (h : filter.tendsto (λ (x : α), f x + g x) l filter.at_top) :
theorem filter.tendsto_at_bot_of_add_bdd_below_left' {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (C : β) (hC : ∀ᶠ (x : α) in l, C f x) (h : filter.tendsto (λ (x : α), f x + g x) l filter.at_bot) :
theorem filter.tendsto_at_top_of_add_bdd_above_left {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (C : β) (hC : ∀ (x : α), f x C) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_of_add_bdd_below_left {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (C : β) (hC : ∀ (x : α), C f x) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto_at_top_of_add_bdd_above_right' {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (C : β) (hC : ∀ᶠ (x : α) in l, g x C) (h : filter.tendsto (λ (x : α), f x + g x) l filter.at_top) :
theorem filter.tendsto_at_bot_of_add_bdd_below_right' {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (C : β) (hC : ∀ᶠ (x : α) in l, C g x) (h : filter.tendsto (λ (x : α), f x + g x) l filter.at_bot) :
theorem filter.tendsto_at_top_of_add_bdd_above_right {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (C : β) (hC : ∀ (x : α), g x C) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_of_add_bdd_below_right {α : Type u_3} {β : Type u_4} {l : filter α} {f g : α → β} (C : β) (hC : ∀ (x : α), C g x) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto_at_top_add_left_of_le' {α : Type u_3} {β : Type u_4} (l : filter α) {f g : α → β} (C : β) (hf : ∀ᶠ (x : α) in l, C f x) (hg : filter.at_top) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_add_left_of_ge' {α : Type u_3} {β : Type u_4} (l : filter α) {f g : α → β} (C : β) (hf : ∀ᶠ (x : α) in l, f x C) (hg : filter.at_bot) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto_at_top_add_left_of_le {α : Type u_3} {β : Type u_4} (l : filter α) {f g : α → β} (C : β) (hf : ∀ (x : α), C f x) (hg : filter.at_top) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_add_left_of_ge {α : Type u_3} {β : Type u_4} (l : filter α) {f g : α → β} (C : β) (hf : ∀ (x : α), f x C) (hg : filter.at_bot) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto_at_top_add_right_of_le' {α : Type u_3} {β : Type u_4} (l : filter α) {f g : α → β} (C : β) (hf : filter.at_top) (hg : ∀ᶠ (x : α) in l, C g x) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_add_right_of_ge' {α : Type u_3} {β : Type u_4} (l : filter α) {f g : α → β} (C : β) (hf : filter.at_bot) (hg : ∀ᶠ (x : α) in l, g x C) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto_at_top_add_right_of_le {α : Type u_3} {β : Type u_4} (l : filter α) {f g : α → β} (C : β) (hf : filter.at_top) (hg : ∀ (x : α), C g x) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_top
theorem filter.tendsto_at_bot_add_right_of_ge {α : Type u_3} {β : Type u_4} (l : filter α) {f g : α → β} (C : β) (hf : filter.at_bot) (hg : ∀ (x : α), g x C) :
filter.tendsto (λ (x : α), f x + g x) l filter.at_bot
theorem filter.tendsto_at_top_add_const_left {α : Type u_3} {β : Type u_4} (l : filter α) {f : α → β} (C : β) (hf : filter.at_top) :
filter.tendsto (λ (x : α), C + f x) l filter.at_top
theorem filter.tendsto_at_bot_add_const_left {α : Type u_3} {β : Type u_4} (l : filter α) {f : α → β} (C : β) (hf : filter.at_bot) :
filter.tendsto (λ (x : α), C + f x) l filter.at_bot
theorem filter.tendsto_at_top_add_const_right {α : Type u_3} {β : Type u_4} (l : filter α) {f : α → β} (C : β) (hf : filter.at_top) :
filter.tendsto (λ (x : α), f x + C) l filter.at_top
theorem filter.tendsto_at_bot_add_const_right {α : Type u_3} {β : Type u_4} (l : filter α) {f : α → β} (C : β) (hf : filter.at_bot) :
filter.tendsto (λ (x : α), f x + C) l filter.at_bot
theorem filter.tendsto_neg_at_top_at_bot {β : Type u_4}  :
theorem filter.tendsto_neg_at_bot_at_top {β : Type u_4}  :
theorem filter.tendsto_bit1_at_top {α : Type u_3}  :
theorem filter.tendsto.at_top_mul_at_top {α : Type u_3} {β : Type u_4} {l : filter β} {f g : β → α} (hf : filter.at_top) (hg : filter.at_top) :
filter.tendsto (λ (x : β), (f x) * g x) l filter.at_top
theorem filter.tendsto_mul_self_at_top {α : Type u_3}  :
theorem filter.tendsto_pow_at_top {α : Type u_3} {n : } (hn : 1 n) :

The monomial function x^n tends to +∞ at +∞ for any positive natural n. A version for positive real powers exists as tendsto_rpow_at_top.

theorem filter.eventually_ne_of_tendsto_at_top {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} [nontrivial α] (hf : filter.at_top) (c : α) :
∀ᶠ (x : β) in l, f x c
theorem filter.zero_pow_eventually_eq {α : Type u_3}  :
(λ (n : ), 0 ^ n) =ᶠ[filter.at_top] λ (n : ), 0
theorem filter.eventually_ne_of_tendsto_at_bot {α : Type u_3} {β : Type u_4} [ordered_ring α] {l : filter β} {f : β → α} [nontrivial α] (hf : filter.at_bot) (c : α) :
∀ᶠ (x : β) in l, f x c
theorem filter.tendsto.at_top_mul_at_bot {α : Type u_3} {β : Type u_4} [ordered_ring α] {l : filter β} {f g : β → α} (hf : filter.at_top) (hg : filter.at_bot) :
filter.tendsto (λ (x : β), (f x) * g x) l filter.at_bot
theorem filter.tendsto.at_bot_mul_at_top {α : Type u_3} {β : Type u_4} [ordered_ring α] {l : filter β} {f g : β → α} (hf : filter.at_bot) (hg : filter.at_top) :
filter.tendsto (λ (x : β), (f x) * g x) l filter.at_bot
theorem filter.tendsto.at_bot_mul_at_bot {α : Type u_3} {β : Type u_4} [ordered_ring α] {l : filter β} {f g : β → α} (hf : filter.at_bot) (hg : filter.at_bot) :
filter.tendsto (λ (x : β), (f x) * g x) l filter.at_top
theorem filter.tendsto_abs_at_top_at_top {α : Type u_3}  :

$\lim_{x\to+\infty}|x|=+\infty$

theorem filter.tendsto_abs_at_bot_at_top {α : Type u_3}  :

$\lim_{x\to-\infty}|x|=+\infty$

@[simp]
theorem filter.comap_abs_at_top {α : Type u_3}  :
theorem filter.tendsto.at_top_of_const_mul {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {c : α} (hc : 0 < c) (hf : filter.tendsto (λ (x : β), c * f x) l filter.at_top) :
theorem filter.tendsto.at_top_of_mul_const {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {c : α} (hc : 0 < c) (hf : filter.tendsto (λ (x : β), (f x) * c) l filter.at_top) :
theorem filter.nonneg_of_eventually_pow_nonneg {α : Type u_3} {a : α} (h : ∀ᶠ (n : ) in filter.at_top, 0 a ^ n) :
0 a
theorem filter.tendsto.const_mul_at_top {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {r : α} (hr : 0 < r) (hf : filter.at_top) :
filter.tendsto (λ (x : β), r * f x) l filter.at_top

If a function tends to infinity along a filter, then this function multiplied by a positive constant (on the left) also tends to infinity. For a version working in ℕ or ℤ, use filter.tendsto.const_mul_at_top' instead.

theorem filter.tendsto.at_top_mul_const {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {r : α} (hr : 0 < r) (hf : filter.at_top) :
filter.tendsto (λ (x : β), (f x) * r) l filter.at_top

If a function tends to infinity along a filter, then this function multiplied by a positive constant (on the right) also tends to infinity. For a version working in ℕ or ℤ, use filter.tendsto.at_top_mul_const' instead.

theorem filter.tendsto.at_top_div_const {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {r : α} (hr : 0 < r) (hf : filter.at_top) :
filter.tendsto (λ (x : β), f x / r) l filter.at_top

If a function tends to infinity along a filter, then this function divided by a positive constant also tends to infinity.

theorem filter.tendsto.neg_const_mul_at_top {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {r : α} (hr : r < 0) (hf : filter.at_top) :
filter.tendsto (λ (x : β), r * f x) l filter.at_bot

If a function tends to infinity along a filter, then this function multiplied by a negative constant (on the left) tends to negative infinity.

theorem filter.tendsto.at_top_mul_neg_const {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {r : α} (hr : r < 0) (hf : filter.at_top) :
filter.tendsto (λ (x : β), (f x) * r) l filter.at_bot

If a function tends to infinity along a filter, then this function multiplied by a negative constant (on the right) tends to negative infinity.

theorem filter.tendsto.const_mul_at_bot {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {r : α} (hr : 0 < r) (hf : filter.at_bot) :
filter.tendsto (λ (x : β), r * f x) l filter.at_bot

If a function tends to negative infinity along a filter, then this function multiplied by a positive constant (on the left) also tends to negative infinity.

theorem filter.tendsto.at_bot_mul_const {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {r : α} (hr : 0 < r) (hf : filter.at_bot) :
filter.tendsto (λ (x : β), (f x) * r) l filter.at_bot

If a function tends to negative infinity along a filter, then this function multiplied by a positive constant (on the right) also tends to negative infinity.

theorem filter.tendsto.at_bot_div_const {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {r : α} (hr : 0 < r) (hf : filter.at_bot) :
filter.tendsto (λ (x : β), f x / r) l filter.at_bot

If a function tends to negative infinity along a filter, then this function divided by a positive constant also tends to negative infinity.

theorem filter.tendsto.neg_const_mul_at_bot {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {r : α} (hr : r < 0) (hf : filter.at_bot) :
filter.tendsto (λ (x : β), r * f x) l filter.at_top

If a function tends to negative infinity along a filter, then this function multiplied by a negative constant (on the left) tends to positive infinity.

theorem filter.tendsto.at_bot_mul_neg_const {α : Type u_3} {β : Type u_4} {l : filter β} {f : β → α} {r : α} (hr : r < 0) (hf : filter.at_bot) :
filter.tendsto (λ (x : β), (f x) * r) l filter.at_top

If a function tends to negative infinity along a filter, then this function multiplied by a negative constant (on the right) tends to positive infinity.

theorem filter.tendsto_const_mul_pow_at_top {α : Type u_3} {c : α} {n : } (hn : 1 n) (hc : 0 < c) :
theorem filter.tendsto_const_mul_pow_at_top_iff {α : Type u_3} (c : α) (n : ) :
filter.tendsto (λ (x : α), c * x ^ n) filter.at_top filter.at_top 1 n 0 < c
theorem filter.tendsto_neg_const_mul_pow_at_top {α : Type u_3} {c : α} {n : } (hn : 1 n) (hc : c < 0) :
theorem filter.tendsto_neg_const_mul_pow_at_top_iff {α : Type u_3} (c : α) (n : ) :
filter.tendsto (λ (x : α), c * x ^ n) filter.at_top filter.at_bot 1 n c < 0
theorem filter.tendsto_at_top' {α : Type u_3} {β : Type u_4} [nonempty α] {f : α → β} {l : filter β} :
∀ (s : set β), s l(∃ (a : α), ∀ (b : α), b af b s)
theorem filter.tendsto_at_bot' {α : Type u_3} {β : Type u_4} [nonempty α] {f : α → β} {l : filter β} :
∀ (s : set β), s l(∃ (a : α), ∀ (b : α), b af b s)
theorem filter.tendsto_at_top_principal {α : Type u_3} {β : Type u_4} [nonempty β] {f : β → α} {s : set α} :
(𝓟 s) ∃ (N : β), ∀ (n : β), n Nf n s
theorem filter.tendsto_at_bot_principal {α : Type u_3} {β : Type u_4} [nonempty β] {f : β → α} {s : set α} :
(𝓟 s) ∃ (N : β), ∀ (n : β), n Nf n s
theorem filter.tendsto_at_top_at_top {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] {f : α → β} :
∀ (b : β), ∃ (i : α), ∀ (a : α), i ab f a

A function f grows to +∞ independent of an order-preserving embedding e.

theorem filter.tendsto_at_top_at_bot {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] {f : α → β} :
∀ (b : β), ∃ (i : α), ∀ (a : α), i af a b
theorem filter.tendsto_at_bot_at_top {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] {f : α → β} :
∀ (b : β), ∃ (i : α), ∀ (a : α), a ib f a
theorem filter.tendsto_at_bot_at_bot {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] {f : α → β} :
∀ (b : β), ∃ (i : α), ∀ (a : α), a if a b
theorem filter.tendsto_at_top_at_top_of_monotone {α : Type u_3} {β : Type u_4} [preorder α] [preorder β] {f : α → β} (hf : monotone f) (h : ∀ (b : β), ∃ (a : α), b f a) :
theorem filter.tendsto_at_bot_at_bot_of_monotone {α : Type u_3} {β : Type u_4} [preorder α] [preorder β] {f : α → β} (hf : monotone f) (h : ∀ (b : β), ∃ (a : α), f a b) :
theorem filter.tendsto_at_top_at_top_iff_of_monotone {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] {f : α → β} (hf : monotone f) :
∀ (b : β), ∃ (a : α), b f a
theorem filter.tendsto_at_bot_at_bot_iff_of_monotone {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] {f : α → β} (hf : monotone f) :
∀ (b : β), ∃ (a : α), f a b
theorem monotone.tendsto_at_top_at_top {α : Type u_3} {β : Type u_4} [preorder α] [preorder β] {f : α → β} (hf : monotone f) (h : ∀ (b : β), ∃ (a : α), b f a) :

Alias of tendsto_at_top_at_top_of_monotone.

theorem monotone.tendsto_at_bot_at_bot {α : Type u_3} {β : Type u_4} [preorder α] [preorder β] {f : α → β} (hf : monotone f) (h : ∀ (b : β), ∃ (a : α), f a b) :

Alias of tendsto_at_bot_at_bot_of_monotone.

theorem monotone.tendsto_at_top_at_top_iff {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] {f : α → β} (hf : monotone f) :
∀ (b : β), ∃ (a : α), b f a

Alias of tendsto_at_top_at_top_iff_of_monotone.

theorem monotone.tendsto_at_bot_at_bot_iff {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] {f : α → β} (hf : monotone f) :
∀ (b : β), ∃ (a : α), f a b

Alias of tendsto_at_bot_at_bot_iff_of_monotone.

theorem filter.comap_embedding_at_top {β : Type u_4} {γ : Type u_5} [preorder β] [preorder γ] {e : β → γ} (hm : ∀ (b₁ b₂ : β), e b₁ e b₂ b₁ b₂) (hu : ∀ (c : γ), ∃ (b : β), c e b) :
theorem filter.comap_embedding_at_bot {β : Type u_4} {γ : Type u_5} [preorder β] [preorder γ] {e : β → γ} (hm : ∀ (b₁ b₂ : β), e b₁ e b₂ b₁ b₂) (hu : ∀ (c : γ), ∃ (b : β), e b c) :
theorem filter.tendsto_at_top_embedding {α : Type u_3} {β : Type u_4} {γ : Type u_5} [preorder β] [preorder γ] {f : α → β} {e : β → γ} {l : filter α} (hm : ∀ (b₁ b₂ : β), e b₁ e b₂ b₁ b₂) (hu : ∀ (c : γ), ∃ (b : β), c e b) :
theorem filter.tendsto_at_bot_embedding {α : Type u_3} {β : Type u_4} {γ : Type u_5} [preorder β] [preorder γ] {f : α → β} {e : β → γ} {l : filter α} (hm : ∀ (b₁ b₂ : β), e b₁ e b₂ b₁ b₂) (hu : ∀ (c : γ), ∃ (b : β), e b c) :

A function f goes to -∞ independent of an order-preserving embedding e.

theorem filter.at_top_finset_eq_infi {α : Type u_3} :
filter.at_top = ⨅ (x : α), 𝓟 (set.Ici {x})
theorem filter.tendsto_at_top_finset_of_monotone {α : Type u_3} {β : Type u_4} [preorder β] {f : β → } (h : monotone f) (h' : ∀ (x : α), ∃ (n : β), x f n) :

If f is a monotone sequence of finsets and each x belongs to one of f n, then tendsto f at_top at_top.

theorem monotone.tendsto_at_top_finset {α : Type u_3} {β : Type u_4} [preorder β] {f : β → } (h : monotone f) (h' : ∀ (x : α), ∃ (n : β), x f n) :

Alias of tendsto_at_top_finset_of_monotone.

theorem filter.tendsto_finset_image_at_top_at_top {β : Type u_4} {γ : Type u_5} {i : β → γ} {j : γ → β} (h : i) :
theorem filter.tendsto_finset_preimage_at_top_at_top {α : Type u_3} {β : Type u_4} {f : α → β} (hf : function.injective f) :
theorem filter.prod_at_top_at_top_eq {β₁ : Type u_1} {β₂ : Type u_2} [semilattice_sup β₁] [semilattice_sup β₂] :
theorem filter.prod_at_bot_at_bot_eq {β₁ : Type u_1} {β₂ : Type u_2} [semilattice_inf β₁] [semilattice_inf β₂] :
theorem filter.prod_map_at_top_eq {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} [semilattice_sup β₁] [semilattice_sup β₂] (u₁ : β₁ → α₁) (u₂ : β₂ → α₂) :
theorem filter.prod_map_at_bot_eq {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} [semilattice_inf β₁] [semilattice_inf β₂] (u₁ : β₁ → α₁) (u₂ : β₂ → α₂) :
theorem filter.tendsto.subseq_mem {α : Type u_3} {F : filter α} {V : set α} (h : ∀ (n : ), V n F) {u : → α} (hu : F) :
∃ (φ : ), ∀ (n : ), u (φ n) V n
theorem filter.tendsto_at_bot_diagonal {α : Type u_3}  :
theorem filter.tendsto_at_top_diagonal {α : Type u_3}  :
theorem filter.tendsto.prod_map_prod_at_bot {α : Type u_3} {β : Type u_4} {γ : Type u_5} {F : filter α} {G : filter β} {f : α → γ} {g : β → γ} (hf : filter.at_bot) (hg : filter.at_bot) :
theorem filter.tendsto.prod_map_prod_at_top {α : Type u_3} {β : Type u_4} {γ : Type u_5} {F : filter α} {G : filter β} {f : α → γ} {g : β → γ} (hf : filter.at_top) (hg : filter.at_top) :
theorem filter.tendsto.prod_at_bot {α : Type u_3} {γ : Type u_5} {f g : α → γ}  :
theorem filter.tendsto.prod_at_top {α : Type u_3} {γ : Type u_5} {f g : α → γ}  :
theorem filter.eventually_at_bot_prod_self {α : Type u_3} [nonempty α] {p : α × α → Prop} :
(∀ᶠ (x : α × α) in filter.at_bot, p x) ∃ (a : α), ∀ (k l : α), k al ap (k, l)
theorem filter.eventually_at_top_prod_self {α : Type u_3} [nonempty α] {p : α × α → Prop} :
(∀ᶠ (x : α × α) in filter.at_top, p x) ∃ (a : α), ∀ (k l : α), a ka lp (k, l)
theorem filter.eventually_at_bot_prod_self' {α : Type u_3} [nonempty α] {p : α × α → Prop} :
(∀ᶠ (x : α × α) in filter.at_bot, p x) ∃ (a : α), ∀ (k : α), k a∀ (l : α), l ap (k, l)
theorem filter.eventually_at_top_prod_self' {α : Type u_3} [nonempty α] {p : α × α → Prop} :
(∀ᶠ (x : α × α) in filter.at_top, p x) ∃ (a : α), ∀ (k : α), k a∀ (l : α), l ap (k, l)
theorem filter.eventually_at_top_curry {α : Type u_3} {β : Type u_4} {p : α × β → Prop} (hp : ∀ᶠ (x : α × β) in filter.at_top, p x) :
∀ᶠ (k : α) in filter.at_top, ∀ᶠ (l : β) in filter.at_top, p (k, l)
theorem filter.eventually_at_bot_curry {α : Type u_3} {β : Type u_4} {p : α × β → Prop} (hp : ∀ᶠ (x : α × β) in filter.at_bot, p x) :
∀ᶠ (k : α) in filter.at_bot, ∀ᶠ (l : β) in filter.at_bot, p (k, l)
theorem filter.map_at_top_eq_of_gc {α : Type u_3} {β : Type u_4} {f : α → β} (g : β → α) (b' : β) (hf : monotone f) (gc : ∀ (a : α) (b : β), b b'(f a b a g b)) (hgi : ∀ (b : β), b b'b f (g b)) :

A function f maps upwards closed sets (at_top 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 connetion above b'.

theorem filter.map_at_bot_eq_of_gc {α : Type u_3} {β : Type u_4} {f : α → β} (g : β → α) (b' : β) (hf : monotone f) (gc : ∀ (a : α) (b : β), b b'(b f a g b a)) (hgi : ∀ (b : β), b b'f (g b) b) :
theorem filter.map_coe_at_top_of_Ici_subset {α : Type u_3} {a : α} {s : set α} (h : s) :
@[simp]
theorem filter.map_coe_Ici_at_top {α : Type u_3} (a : α) :

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

@[simp]
theorem filter.map_coe_Ioi_at_top {α : Type u_3} [no_max_order α] (a : α) :

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

theorem filter.at_top_Ioi_eq {α : Type u_3} (a : α) :

The at_top filter for an open interval Ioi a comes from the at_top filter in the ambient order.

theorem filter.at_top_Ici_eq {α : Type u_3} (a : α) :

The at_top filter for an open interval Ici a comes from the at_top filter in the ambient order.

@[simp]
theorem filter.map_coe_Iio_at_bot {α : Type u_3} [no_min_order α] (a : α) :

The at_bot filter for an open interval Iio a comes from the at_bot filter in the ambient order.

theorem filter.at_bot_Iio_eq {α : Type u_3} (a : α) :

The at_bot filter for an open interval Iio a comes from the at_bot filter in the ambient order.

@[simp]
theorem filter.map_coe_Iic_at_bot {α : Type u_3} (a : α) :

The at_bot filter for an open interval Iic a comes from the at_bot filter in the ambient order.

theorem filter.at_bot_Iic_eq {α : Type u_3} (a : α) :

The at_bot filter for an open interval Iic a comes from the at_bot filter in the ambient order.

theorem filter.tendsto_Ioi_at_top {α : Type u_3} {β : Type u_4} {a : α} {f : β → (set.Ioi a)} {l : filter β} :
filter.tendsto (λ (x : β), (f x)) l filter.at_top
theorem filter.tendsto_Iio_at_bot {α : Type u_3} {β : Type u_4} {a : α} {f : β → (set.Iio a)} {l : filter β} :
filter.tendsto (λ (x : β), (f x)) l filter.at_bot
theorem filter.tendsto_Ici_at_top {α : Type u_3} {β : Type u_4} {a : α} {f : β → (set.Ici a)} {l : filter β} :
filter.tendsto (λ (x : β), (f x)) l filter.at_top
theorem filter.tendsto_Iic_at_bot {α : Type u_3} {β : Type u_4} {a : α} {f : β → (set.Iic a)} {l : filter β} :
filter.tendsto (λ (x : β), (f x)) l filter.at_bot
@[simp]
theorem filter.tendsto_comp_coe_Ioi_at_top {α : Type u_3} {β : Type u_4} [no_max_order α] {a : α} {f : α → β} {l : filter β} :
@[simp]
theorem filter.tendsto_comp_coe_Ici_at_top {α : Type u_3} {β : Type u_4} {a : α} {f : α → β} {l : filter β} :
@[simp]
theorem filter.tendsto_comp_coe_Iio_at_bot {α : Type u_3} {β : Type u_4} [no_min_order α] {a : α} {f : α → β} {l : filter β} :
@[simp]
theorem filter.tendsto_comp_coe_Iic_at_bot {α : Type u_3} {β : Type u_4} {a : α} {f : α → β} {l : filter β} :
theorem filter.tendsto_add_at_top_iff_nat {α : Type u_3} {f : → α} {l : filter α} (k : ) :
filter.tendsto (λ (n : ), f (n + k)) filter.at_top l
theorem filter.map_div_at_top_eq_nat (k : ) (hk : 0 < k) :
theorem filter.tendsto_at_top_at_top_of_monotone' {ι : Type u_1} {α : Type u_3} [preorder ι] [linear_order α] {u : ι → α} (h : monotone u) (H : ¬) :

If u is a monotone function with linear ordered codomain and the range of u is not bounded above, then tendsto u at_top at_top.

theorem filter.tendsto_at_bot_at_bot_of_monotone' {ι : Type u_1} {α : Type u_3} [preorder ι] [linear_order α] {u : ι → α} (h : monotone u) (H : ¬) :

If u is a monotone function with linear ordered codomain and the range of u is not bounded below, then tendsto u at_bot at_bot.

theorem filter.unbounded_of_tendsto_at_top {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] [no_max_order β] {f : α → β}  :
theorem filter.unbounded_of_tendsto_at_bot {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] [no_min_order β] {f : α → β}  :
theorem filter.unbounded_of_tendsto_at_top' {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] [no_max_order β] {f : α → β}  :
theorem filter.unbounded_of_tendsto_at_bot' {α : Type u_3} {β : Type u_4} [nonempty α] [preorder β] [no_min_order β] {f : α → β}  :
theorem filter.tendsto_at_top_of_monotone_of_filter {ι : Type u_1} {α : Type u_3} [preorder ι] [preorder α] {l : filter ι} {u : ι → α} (h : monotone u) [l.ne_bot] (hu : filter.at_top) :

If a monotone function u : ι → α tends to at_top along some non-trivial filter l, then it tends to at_top along at_top.

theorem filter.tendsto_at_bot_of_monotone_of_filter {ι : Type u_1} {α : Type u_3} [preorder ι] [preorder α] {l : filter ι} {u : ι → α} (h : monotone u) [l.ne_bot] (hu : filter.at_bot) :

If a monotone function u : ι → α tends to at_bot along some non-trivial filter l, then it tends to at_bot along at_bot.

theorem filter.tendsto_at_top_of_monotone_of_subseq {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [preorder ι] [preorder α] {u : ι → α} {φ : ι' → ι} (h : monotone u) {l : filter ι'} [l.ne_bot] (H : filter.tendsto (u φ) l filter.at_top) :
theorem filter.tendsto_at_bot_of_monotone_of_subseq {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [preorder ι] [preorder α] {u : ι → α} {φ : ι' → ι} (h : monotone u) {l : filter ι'} [l.ne_bot] (H : filter.tendsto (u φ) l filter.at_bot) :
theorem filter.map_at_top_finset_prod_le_of_prod_eq {α : Type u_3} {β : Type u_4} {γ : Type u_5} [comm_monoid α] {f : β → α} {g : γ → α} (h_eq : ∀ (u : finset γ), ∃ (v : finset β), ∀ (v' : finset β), v v'(∃ (u' : finset γ), u u' ∏ (x : γ) in u', g x = ∏ (b : β) in v', f b)) :
filter.map (λ (s : finset β), ∏ (b : β) in s, f b) filter.at_top filter.map (λ (s : finset γ), ∏ (x : γ) in s, g x) filter.at_top

Let f and g be two maps to the same commutative monoid. This lemma gives a sufficient condition for comparison of the filter at_top.map (λ s, ∏ b in s, f b) with at_top.map (λ s, ∏ b in s, g b). This is useful to compare the set of limit points of Π b in s, f b as s → at_top with the similar set for g.

theorem filter.map_at_top_finset_sum_le_of_sum_eq {α : Type u_3} {β : Type u_4} {γ : Type u_5} {f : β → α} {g : γ → α} (h_eq : ∀ (u : finset γ), ∃ (v : finset β), ∀ (v' : finset β), v v'(∃ (u' : finset γ), u u' ∑ (x : γ) in u', g x = ∑ (b : β) in v', f b)) :
filter.map (λ (s : finset β), ∑ (b : β) in s, f b) filter.at_top filter.map (λ (s : finset γ), ∑ (x : γ) in s, g x) filter.at_top
theorem filter.has_antitone_basis.tendsto {ι : Type u_1} {α : Type u_3} [nonempty ι] {l : filter α} {s : ι → set α} (hl : l.has_antitone_basis s) {φ : ι → α} (h : ∀ (i : ι), φ i s i) :
theorem filter.exists_seq_tendsto {α : Type u_3} (f : filter α) [f.ne_bot] :
∃ (x : → α),

If f is a nontrivial countably generated filter, then there exists a sequence that converges to f.

theorem filter.tendsto_iff_seq_tendsto {α : Type u_3} {β : Type u_4} {f : α → β} {k : filter α} {l : filter β}  :
l ∀ (x : → α), filter.tendsto (f x) filter.at_top l

An abstract version of continuity of sequentially continuous functions on metric spaces: if a filter k is countably generated then tendsto f k l iff for every sequence u converging to k, f ∘ u tends to l.

theorem filter.tendsto_of_seq_tendsto {α : Type u_3} {β : Type u_4} {f : α → β} {k : filter α} {l : filter β}  :
(∀ (x : → α), filter.tendsto (f x) filter.at_top l) l
theorem filter.subseq_tendsto_of_ne_bot {α : Type u_3} {f : filter α} {u : → α} (hx : (f .ne_bot) :
∃ (θ : ), filter.tendsto (u θ) filter.at_top f
theorem exists_lt_mul_self {R : Type u_6} (a : R) :
∃ (x : R) (H : x 0), a < x * x
theorem exists_le_mul_self {R : Type u_6} (a : R) :
∃ (x : R) (H : x 0), a x * x
@[simp]
theorem order_iso.comap_at_top {α : Type u_3} {β : Type u_4} [preorder α] [preorder β] (e : α ≃o β) :
@[simp]
theorem order_iso.comap_at_bot {α : Type u_3} {β : Type u_4} [preorder α] [preorder β] (e : α ≃o β) :
@[simp]
theorem order_iso.map_at_top {α : Type u_3} {β : Type u_4} [preorder α] [preorder β] (e : α ≃o β) :
@[simp]
theorem order_iso.map_at_bot {α : Type u_3} {β : Type u_4} [preorder α] [preorder β] (e : α ≃o β) :
theorem order_iso.tendsto_at_top {α : Type u_3} {β : Type u_4} [preorder α] [preorder β] (e : α ≃o β) :
theorem order_iso.tendsto_at_bot {α : Type u_3} {β : Type u_4} [preorder α] [preorder β] (e : α ≃o β) :
@[simp]
theorem order_iso.tendsto_at_top_iff {α : Type u_3} {β : Type u_4} {γ : Type u_5} [preorder α] [preorder β] {l : filter γ} {f : γ → α} (e : α ≃o β) :
filter.tendsto (λ (x : γ), e (f x)) l filter.at_top
@[simp]
theorem order_iso.tendsto_at_bot_iff {α : Type u_3} {β : Type u_4} {γ : Type u_5} [preorder α] [preorder β] {l : filter γ} {f : γ → α} (e : α ≃o β) :
filter.tendsto (λ (x : γ), e (f x)) l filter.at_bot
theorem function.injective.map_at_top_finset_sum_eq {α : Type u_3} {β : Type u_4} {γ : Type u_5} {g : γ → β} (hg : function.injective g) {f : β → α} (hf : ∀ (x : β), x f x = 0) :
filter.map (λ (s : finset γ), ∑ (i : γ) in s, f (g i)) filter.at_top = filter.map (λ (s : finset β), ∑ (i : β) in s, f i) filter.at_top

Let g : γ → β be an injective function and f : β → α be a function from the codomain of g to an additive commutative monoid. Suppose that f x = 0 outside of the range of g. Then the filters at_top.map (λ s, ∑ i in s, f (g i)) and at_top.map (λ s, ∑ i in s, f i) coincide.

This lemma is used to prove the equality ∑' x, f (g x) = ∑' y, f y under the same assumptions.

theorem function.injective.map_at_top_finset_prod_eq {α : Type u_3} {β : Type u_4} {γ : Type u_5} [comm_monoid α] {g : γ → β} (hg : function.injective g) {f : β → α} (hf : ∀ (x : β), x f x = 1) :
filter.map (λ (s : finset γ), ∏ (i : γ) in s, f (g i)) filter.at_top = filter.map (λ (s : finset β), ∏ (i : β) in s, f i) filter.at_top

Let g : γ → β be an injective function and f : β → α be a function from the codomain of g to a commutative monoid. Suppose that f x = 1 outside of the range of g. Then the filters at_top.map (λ s, ∏ i in s, f (g i)) and at_top.map (λ s, ∏ i in s, f i) coincide.

The additive version of this lemma is used to prove the equality ∑' x, f (g x) = ∑' y, f y under the same assumptions.