File: Mathlib/Order/Filter/AtTopBot.lean

full_name: Filter.atTop
code: /-- `atTop` 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.) -/
def atTop [Preorder α] : Filter α 
goal: Filter α

full_name: Filter.atBot
code: /-- `atBot` 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.) -/
def atBot [Preorder α] : Filter α 
goal: Filter α

full_name: Filter.mem_atTop
code: theorem mem_atTop [Preorder α] (a : α) : { b : α | a ≤ b } ∈ @atTop α _ 
goal: {b | a ≤ b} ∈ Filter.atTop

full_name: Filter.Ici_mem_atTop
code: theorem Ici_mem_atTop [Preorder α] (a : α) : Ici a ∈ (atTop : Filter α) 
goal: Set.Ici a ∈ Filter.atTop

full_name: Filter.Ioi_mem_atTop
code: theorem Ioi_mem_atTop [Preorder α] [NoMaxOrder α] (x : α) : Ioi x ∈ (atTop : Filter α) 
goal: Set.Ioi x ∈ Filter.atTop

full_name: Filter.mem_atBot
code: theorem mem_atBot [Preorder α] (a : α) : { b : α | b ≤ a } ∈ @atBot α _ 
goal: {b | b ≤ a} ∈ Filter.atBot

full_name: Filter.Iic_mem_atBot
code: theorem Iic_mem_atBot [Preorder α] (a : α) : Iic a ∈ (atBot : Filter α) 
goal: Set.Iic a ∈ Filter.atBot

full_name: Filter.Iio_mem_atBot
code: theorem Iio_mem_atBot [Preorder α] [NoMinOrder α] (x : α) : Iio x ∈ (atBot : Filter α) 
goal: Set.Iio x ∈ Filter.atBot

full_name: Filter.disjoint_atBot_principal_Ioi
code: theorem disjoint_atBot_principal_Ioi [Preorder α] (x : α) : Disjoint atBot (𝓟 (Ioi x)) 
goal: Disjoint Filter.atBot (𝓟 (Set.Ioi x))

full_name: Filter.disjoint_atTop_principal_Iio
code: theorem disjoint_atTop_principal_Iio [Preorder α] (x : α) : Disjoint atTop (𝓟 (Iio x)) 
goal: Disjoint Filter.atTop (𝓟 (Set.Iio x))

full_name: Filter.disjoint_atTop_principal_Iic
code: theorem disjoint_atTop_principal_Iic [Preorder α] [NoMaxOrder α] (x : α) :
    Disjoint atTop (𝓟 (Iic x)) 
goal: Disjoint Filter.atTop (𝓟 (Set.Iic x))

full_name: Filter.disjoint_atBot_principal_Ici
code: theorem disjoint_atBot_principal_Ici [Preorder α] [NoMinOrder α] (x : α) :
    Disjoint atBot (𝓟 (Ici x)) 
goal: Disjoint Filter.atBot (𝓟 (Set.Ici x))

full_name: Filter.disjoint_pure_atTop
code: theorem disjoint_pure_atTop [Preorder α] [NoMaxOrder α] (x : α) : Disjoint (pure x) atTop 
goal: Disjoint (pure x) Filter.atTop

full_name: Filter.disjoint_pure_atBot
code: theorem disjoint_pure_atBot [Preorder α] [NoMinOrder α] (x : α) : Disjoint (pure x) atBot 
goal: Disjoint (pure x) Filter.atBot

full_name: Filter.not_tendsto_const_atTop
code: theorem not_tendsto_const_atTop [Preorder α] [NoMaxOrder α] (x : α) (l : Filter β) [l.NeBot] :
    ¬Tendsto (fun _ => x) l atTop 
goal: ¬Filter.Tendsto (fun x_1 => x) l Filter.atTop

full_name: Filter.not_tendsto_const_atBot
code: theorem not_tendsto_const_atBot [Preorder α] [NoMinOrder α] (x : α) (l : Filter β) [l.NeBot] :
    ¬Tendsto (fun _ => x) l atBot 
goal: ¬Filter.Tendsto (fun x_1 => x) l Filter.atBot

full_name: Filter.disjoint_atBot_atTop
code: theorem disjoint_atBot_atTop [PartialOrder α] [Nontrivial α] :
    Disjoint (atBot : Filter α) atTop 
goal: Disjoint Filter.atBot Filter.atTop

full_name: Filter.disjoint_atTop_atBot
code: theorem disjoint_atTop_atBot [PartialOrder α] [Nontrivial α] : Disjoint (atTop : Filter α) atBot 
goal: Disjoint Filter.atTop Filter.atBot

full_name: Filter.hasAntitoneBasis_atTop
code: theorem hasAntitoneBasis_atTop [Nonempty α] [Preorder α] [IsDirected α (· ≤ ·)] :
    (@atTop α _).HasAntitoneBasis Ici 
goal: Filter.atTop.HasAntitoneBasis Set.Ici

full_name: Filter.atTop_basis
code: theorem atTop_basis [Nonempty α] [SemilatticeSup α] : (@atTop α _).HasBasis (fun _ => True) Ici 
goal: Filter.atTop.HasBasis (fun x => True) Set.Ici

full_name: Filter.atTop_eq_generate_Ici
code: theorem atTop_eq_generate_Ici [SemilatticeSup α] : atTop = generate (range (Ici (α := α))) 
goal: Filter.atTop = Filter.generate (Set.range Set.Ici)

full_name: Filter.atTop_basis'
code: theorem atTop_basis' [SemilatticeSup α] (a : α) : (@atTop α _).HasBasis (fun x => a ≤ x) Ici 
goal: Filter.atTop.HasBasis (fun x => a ≤ x) Set.Ici

full_name: Filter.atBot_basis
code: theorem atBot_basis [Nonempty α] [SemilatticeInf α] : (@atBot α _).HasBasis (fun _ => True) Iic 
goal: Filter.atBot.HasBasis (fun x => True) Set.Iic

full_name: Filter.atBot_basis'
code: theorem atBot_basis' [SemilatticeInf α] (a : α) : (@atBot α _).HasBasis (fun x => x ≤ a) Iic 
goal: Filter.atBot.HasBasis (fun x => x ≤ a) Set.Iic

full_name: Filter.atTop_neBot
code: @[instance]
theorem atTop_neBot [Nonempty α] [SemilatticeSup α] : NeBot (atTop : Filter α) 
goal: Filter.atTop.NeBot

full_name: Filter.atBot_neBot
code: @[instance]
theorem atBot_neBot [Nonempty α] [SemilatticeInf α] : NeBot (atBot : Filter α) 
goal: Filter.atBot.NeBot

full_name: Filter.mem_atTop_sets
code: @[simp]
theorem mem_atTop_sets [Nonempty α] [SemilatticeSup α] {s : Set α} :
    s ∈ (atTop : Filter α) ↔ ∃ a : α, ∀ b ≥ a, b ∈ s 
goal: s ∈ Filter.atTop ↔ ∃ a, ∀ b ≥ a, b ∈ s

full_name: Filter.mem_atBot_sets
code: @[simp]
theorem mem_atBot_sets [Nonempty α] [SemilatticeInf α] {s : Set α} :
    s ∈ (atBot : Filter α) ↔ ∃ a : α, ∀ b ≤ a, b ∈ s 
goal: s ∈ Filter.atBot ↔ ∃ a, ∀ b ≤ a, b ∈ s

full_name: Filter.eventually_atTop
code: @[simp]
theorem eventually_atTop [SemilatticeSup α] [Nonempty α] {p : α → Prop} :
    (∀ᶠ x in atTop, p x) ↔ ∃ a, ∀ b ≥ a, p b 
goal: (∀ᶠ (x : α) in Filter.atTop, p x) ↔ ∃ a, ∀ b ≥ a, p b

full_name: Filter.eventually_atBot
code: @[simp]
theorem eventually_atBot [SemilatticeInf α] [Nonempty α] {p : α → Prop} :
    (∀ᶠ x in atBot, p x) ↔ ∃ a, ∀ b ≤ a, p b 
goal: (∀ᶠ (x : α) in Filter.atBot, p x) ↔ ∃ a, ∀ b ≤ a, p b

full_name: Filter.eventually_ge_atTop
code: theorem eventually_ge_atTop [Preorder α] (a : α) : ∀ᶠ x in atTop, a ≤ x 
goal: ∀ᶠ (x : α) in Filter.atTop, a ≤ x

full_name: Filter.eventually_le_atBot
code: theorem eventually_le_atBot [Preorder α] (a : α) : ∀ᶠ x in atBot, x ≤ a 
goal: ∀ᶠ (x : α) in Filter.atBot, x ≤ a

full_name: Filter.eventually_gt_atTop
code: theorem eventually_gt_atTop [Preorder α] [NoMaxOrder α] (a : α) : ∀ᶠ x in atTop, a < x 
goal: ∀ᶠ (x : α) in Filter.atTop, a < x

full_name: Filter.eventually_ne_atTop
code: theorem eventually_ne_atTop [Preorder α] [NoMaxOrder α] (a : α) : ∀ᶠ x in atTop, x ≠ a 
goal: ∀ᶠ (x : α) in Filter.atTop, x ≠ a

full_name: Filter.Tendsto.eventually_gt_atTop
code: protected theorem Tendsto.eventually_gt_atTop [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atTop) (c : β) : ∀ᶠ x in l, c < f x 
goal: ∀ᶠ (x : α) in l, c < f x

full_name: Filter.Tendsto.eventually_ge_atTop
code: protected theorem Tendsto.eventually_ge_atTop [Preorder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atTop) (c : β) : ∀ᶠ x in l, c ≤ f x 
goal: ∀ᶠ (x : α) in l, c ≤ f x

full_name: Filter.Tendsto.eventually_ne_atTop
code: protected theorem Tendsto.eventually_ne_atTop [Preorder β] [NoMaxOrder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atTop) (c : β) : ∀ᶠ x in l, f x ≠ c 
goal: ∀ᶠ (x : α) in l, f x ≠ c

full_name: Filter.Tendsto.eventually_ne_atTop'
code: protected theorem Tendsto.eventually_ne_atTop' [Preorder β] [NoMaxOrder β] {f : α → β}
    {l : Filter α} (hf : Tendsto f l atTop) (c : α) : ∀ᶠ x in l, x ≠ c 
goal: ∀ᶠ (x : α) in l, x ≠ c

full_name: Filter.eventually_lt_atBot
code: theorem eventually_lt_atBot [Preorder α] [NoMinOrder α] (a : α) : ∀ᶠ x in atBot, x < a 
goal: ∀ᶠ (x : α) in Filter.atBot, x < a

full_name: Filter.eventually_ne_atBot
code: theorem eventually_ne_atBot [Preorder α] [NoMinOrder α] (a : α) : ∀ᶠ x in atBot, x ≠ a 
goal: ∀ᶠ (x : α) in Filter.atBot, x ≠ a

full_name: Filter.Tendsto.eventually_lt_atBot
code: protected theorem Tendsto.eventually_lt_atBot [Preorder β] [NoMinOrder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atBot) (c : β) : ∀ᶠ x in l, f x < c 
goal: ∀ᶠ (x : α) in l, f x < c

full_name: Filter.Tendsto.eventually_le_atBot
code: protected theorem Tendsto.eventually_le_atBot [Preorder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atBot) (c : β) : ∀ᶠ x in l, f x ≤ c 
goal: ∀ᶠ (x : α) in l, f x ≤ c

full_name: Filter.Tendsto.eventually_ne_atBot
code: protected theorem Tendsto.eventually_ne_atBot [Preorder β] [NoMinOrder β] {f : α → β} {l : Filter α}
    (hf : Tendsto f l atBot) (c : β) : ∀ᶠ x in l, f x ≠ c 
goal: ∀ᶠ (x : α) in l, f x ≠ c

full_name: Filter.eventually_forall_ge_atTop
code: theorem eventually_forall_ge_atTop [Preorder α] {p : α → Prop} :
    (∀ᶠ x in atTop, ∀ y, x ≤ y → p y) ↔ ∀ᶠ x in atTop, p x 
goal: (∀ᶠ (x : α) in Filter.atTop, ∀ (y : α), x ≤ y → p y) ↔ ∀ᶠ (x : α) in Filter.atTop, p x

full_name: Filter.eventually_forall_le_atBot
code: theorem eventually_forall_le_atBot [Preorder α] {p : α → Prop} :
    (∀ᶠ x in atBot, ∀ y, y ≤ x → p y) ↔ ∀ᶠ x in atBot, p x 
goal: (∀ᶠ (x : α) in Filter.atBot, ∀ y ≤ x, p y) ↔ ∀ᶠ (x : α) in Filter.atBot, p x

full_name: Filter.Tendsto.eventually_forall_ge_atTop
code: 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 
goal: ∀ᶠ (x : α) in l, ∀ (y : β), f x ≤ y → p y

full_name: Filter.Tendsto.eventually_forall_le_atBot
code: 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 
goal: ∀ᶠ (x : α) in l, ∀ y ≤ f x, p y

full_name: Filter.atTop_basis_Ioi
code: theorem atTop_basis_Ioi [Nonempty α] [SemilatticeSup α] [NoMaxOrder α] :
    (@atTop α _).HasBasis (fun _ => True) Ioi 
goal: Filter.atTop.HasBasis (fun x => True) Set.Ioi

full_name: Filter.atTop_basis_Ioi'
code: lemma atTop_basis_Ioi' [SemilatticeSup α] [NoMaxOrder α] (a : α) : atTop.HasBasis (a < ·) Ioi 
goal: Filter.atTop.HasBasis (fun x => a < x) Set.Ioi

full_name: Filter.atTop_countable_basis
code: theorem atTop_countable_basis [Nonempty α] [SemilatticeSup α] [Countable α] :
    HasCountableBasis (atTop : Filter α) (fun _ => True) Ici 
goal: Filter.atTop.HasCountableBasis (fun x => True) Set.Ici

full_name: Filter.atBot_countable_basis
code: theorem atBot_countable_basis [Nonempty α] [SemilatticeInf α] [Countable α] :
    HasCountableBasis (atBot : Filter α) (fun _ => True) Iic 
goal: Filter.atBot.HasCountableBasis (fun x => True) Set.Iic

full_name: Filter.atTop.isCountablyGenerated
code: instance (priority := 200) atTop.isCountablyGenerated [Preorder α] [Countable α] :
    (atTop : Filter <| α).IsCountablyGenerated 
goal: Filter.atTop.IsCountablyGenerated

full_name: Filter.atBot.isCountablyGenerated
code: instance (priority := 200) atBot.isCountablyGenerated [Preorder α] [Countable α] :
    (atBot : Filter <| α).IsCountablyGenerated 
goal: Filter.atBot.IsCountablyGenerated

full_name: IsTop.atTop_eq
code: theorem _root_.IsTop.atTop_eq [Preorder α] {a : α} (ha : IsTop a) : atTop = 𝓟 (Ici a) 
goal: Filter.atTop = 𝓟 (Set.Ici a)

full_name: IsBot.atBot_eq
code: theorem _root_.IsBot.atBot_eq [Preorder α] {a : α} (ha : IsBot a) : atBot = 𝓟 (Iic a) 
goal: Filter.atBot = 𝓟 (Set.Iic a)

full_name: Filter.OrderTop.atTop_eq
code: theorem OrderTop.atTop_eq (α) [PartialOrder α] [OrderTop α] : (atTop : Filter α) = pure ⊤ 
goal: Filter.atTop = pure ⊤

full_name: Filter.OrderBot.atBot_eq
code: theorem OrderBot.atBot_eq (α) [PartialOrder α] [OrderBot α] : (atBot : Filter α) = pure ⊥ 
goal: Filter.atBot = pure ⊥

full_name: Filter.Subsingleton.atTop_eq
code: @[nontriviality]
theorem Subsingleton.atTop_eq (α) [Subsingleton α] [Preorder α] : (atTop : Filter α) = ⊤ 
goal: Filter.atTop = ⊤

full_name: Filter.Subsingleton.atBot_eq
code: @[nontriviality]
theorem Subsingleton.atBot_eq (α) [Subsingleton α] [Preorder α] : (atBot : Filter α) = ⊤ 
goal: Filter.atBot = ⊤

full_name: Filter.tendsto_atTop_pure
code: theorem tendsto_atTop_pure [PartialOrder α] [OrderTop α] (f : α → β) :
    Tendsto f atTop (pure <| f ⊤) 
goal: Filter.Tendsto f Filter.atTop (pure (f ⊤))

full_name: Filter.tendsto_atBot_pure
code: theorem tendsto_atBot_pure [PartialOrder α] [OrderBot α] (f : α → β) :
    Tendsto f atBot (pure <| f ⊥) 
goal: Filter.Tendsto f Filter.atBot (pure (f ⊥))

full_name: Filter.Eventually.exists_forall_of_atTop
code: theorem Eventually.exists_forall_of_atTop [SemilatticeSup α] [Nonempty α] {p : α → Prop}
    (h : ∀ᶠ x in atTop, p x) : ∃ a, ∀ b ≥ a, p b 
goal: ∃ a, ∀ b ≥ a, p b

full_name: Filter.Eventually.exists_forall_of_atBot
code: theorem Eventually.exists_forall_of_atBot [SemilatticeInf α] [Nonempty α] {p : α → Prop}
    (h : ∀ᶠ x in atBot, p x) : ∃ a, ∀ b ≤ a, p b 
goal: ∃ a, ∀ b ≤ a, p b

full_name: Filter.exists_eventually_atTop
code: lemma exists_eventually_atTop [SemilatticeSup α] [Nonempty α] {r : α → β → Prop} :
    (∃ b, ∀ᶠ a in atTop, r a b) ↔ ∀ᶠ a₀ in atTop, ∃ b, ∀ a ≥ a₀, r a b 
goal: (∃ b, ∀ᶠ (a : α) in Filter.atTop, r a b) ↔ ∀ᶠ (a₀ : α) in Filter.atTop, ∃ b, ∀ a ≥ a₀, r a b

full_name: Filter.exists_eventually_atBot
code: lemma exists_eventually_atBot [SemilatticeInf α] [Nonempty α] {r : α → β → Prop} :
    (∃ b, ∀ᶠ a in atBot, r a b) ↔ ∀ᶠ a₀ in atBot, ∃ b, ∀ a ≤ a₀, r a b 
goal: (∃ b, ∀ᶠ (a : α) in Filter.atBot, r a b) ↔ ∀ᶠ (a₀ : α) in Filter.atBot, ∃ b, ∀ a ≤ a₀, r a b

full_name: Filter.frequently_atTop
code: theorem frequently_atTop [SemilatticeSup α] [Nonempty α] {p : α → Prop} :
    (∃ᶠ x in atTop, p x) ↔ ∀ a, ∃ b ≥ a, p b 
goal: (∃ᶠ (x : α) in Filter.atTop, p x) ↔ ∀ (a : α), ∃ b ≥ a, p b

full_name: Filter.frequently_atBot
code: theorem frequently_atBot [SemilatticeInf α] [Nonempty α] {p : α → Prop} :
    (∃ᶠ x in atBot, p x) ↔ ∀ a, ∃ b ≤ a, p b 
goal: (∃ᶠ (x : α) in Filter.atBot, p x) ↔ ∀ (a : α), ∃ b ≤ a, p b

full_name: Filter.frequently_atTop'
code: theorem frequently_atTop' [SemilatticeSup α] [Nonempty α] [NoMaxOrder α] {p : α → Prop} :
    (∃ᶠ x in atTop, p x) ↔ ∀ a, ∃ b > a, p b 
goal: (∃ᶠ (x : α) in Filter.atTop, p x) ↔ ∀ (a : α), ∃ b > a, p b

full_name: Filter.frequently_atBot'
code: theorem frequently_atBot' [SemilatticeInf α] [Nonempty α] [NoMinOrder α] {p : α → Prop} :
    (∃ᶠ x in atBot, p x) ↔ ∀ a, ∃ b < a, p b 
goal: (∃ᶠ (x : α) in Filter.atBot, p x) ↔ ∀ (a : α), ∃ b < a, p b

full_name: Filter.Frequently.forall_exists_of_atTop
code: theorem Frequently.forall_exists_of_atTop [SemilatticeSup α] [Nonempty α] {p : α → Prop}
    (h : ∃ᶠ x in atTop, p x) : ∀ a, ∃ b ≥ a, p b 
goal: ∃ b ≥ a, p b

full_name: Filter.Frequently.forall_exists_of_atBot
code: theorem Frequently.forall_exists_of_atBot [SemilatticeInf α] [Nonempty α] {p : α → Prop}
    (h : ∃ᶠ x in atBot, p x) : ∀ a, ∃ b ≤ a, p b 
goal: ∃ b ≤ a, p b

full_name: Filter.map_atTop_eq
code: theorem map_atTop_eq [Nonempty α] [SemilatticeSup α] {f : α → β} :
    atTop.map f = ⨅ a, 𝓟 (f '' { a' | a ≤ a' }) 
goal: Filter.map f Filter.atTop = ⨅ a, 𝓟 (f '' {a' | a ≤ a'})

full_name: Filter.map_atBot_eq
code: theorem map_atBot_eq [Nonempty α] [SemilatticeInf α] {f : α → β} :
    atBot.map f = ⨅ a, 𝓟 (f '' { a' | a' ≤ a }) 
goal: Filter.map f Filter.atBot = ⨅ a, 𝓟 (f '' {a' | a' ≤ a})

full_name: Filter.tendsto_atTop
code: theorem tendsto_atTop [Preorder β] {m : α → β} {f : Filter α} :
    Tendsto m f atTop ↔ ∀ b, ∀ᶠ a in f, b ≤ m a 
goal: Filter.Tendsto m f Filter.atTop ↔ ∀ (b : β), ∀ᶠ (a : α) in f, b ≤ m a

full_name: Filter.tendsto_atBot
code: theorem tendsto_atBot [Preorder β] {m : α → β} {f : Filter α} :
    Tendsto m f atBot ↔ ∀ b, ∀ᶠ a in f, m a ≤ b 
goal: Filter.Tendsto m f Filter.atBot ↔ ∀ (b : β), ∀ᶠ (a : α) in f, m a ≤ b

full_name: Filter.tendsto_atTop_mono'
code: theorem tendsto_atTop_mono' [Preorder β] (l : Filter α) ⦃f₁ f₂ : α → β⦄ (h : f₁ ≤ᶠ[l] f₂)
    (h₁ : Tendsto f₁ l atTop) : Tendsto f₂ l atTop 
goal: Filter.Tendsto f₂ l Filter.atTop

full_name: Filter.tendsto_atBot_mono'
code: theorem tendsto_atBot_mono' [Preorder β] (l : Filter α) ⦃f₁ f₂ : α → β⦄ (h : f₁ ≤ᶠ[l] f₂) :
    Tendsto f₂ l atBot → Tendsto f₁ l atBot 
goal: Filter.Tendsto f₂ l Filter.atBot → Filter.Tendsto f₁ l Filter.atBot

full_name: Filter.tendsto_atTop_mono
code: theorem tendsto_atTop_mono [Preorder β] {l : Filter α} {f g : α → β} (h : ∀ n, f n ≤ g n) :
    Tendsto f l atTop → Tendsto g l atTop 
goal: Filter.Tendsto f l Filter.atTop → Filter.Tendsto g l Filter.atTop

full_name: Filter.tendsto_atBot_mono
code: theorem tendsto_atBot_mono [Preorder β] {l : Filter α} {f g : α → β} (h : ∀ n, f n ≤ g n) :
    Tendsto g l atBot → Tendsto f l atBot 
goal: Filter.Tendsto g l Filter.atBot → Filter.Tendsto f l Filter.atBot

full_name: Filter.atTop_eq_generate_of_forall_exists_le
code: lemma atTop_eq_generate_of_forall_exists_le [LinearOrder α] {s : Set α} (hs : ∀ x, ∃ y ∈ s, x ≤ y) :
    (atTop : Filter α) = generate (Ici '' s) 
goal: Filter.atTop = Filter.generate (Set.Ici '' s)

full_name: Filter.atTop_eq_generate_of_not_bddAbove
code: lemma atTop_eq_generate_of_not_bddAbove [LinearOrder α] {s : Set α} (hs : ¬ BddAbove s) :
    (atTop : Filter α) = generate (Ici '' s) 
goal: Filter.atTop = Filter.generate (Set.Ici '' s)

full_name: OrderIso.comap_atTop
code: @[simp]
theorem comap_atTop (e : α ≃o β) : comap e atTop = atTop 
goal: Filter.comap (⇑e) Filter.atTop = Filter.atTop

full_name: OrderIso.comap_atBot
code: @[simp]
theorem comap_atBot (e : α ≃o β) : comap e atBot = atBot 
goal: Filter.comap (⇑e) Filter.atBot = Filter.atBot

full_name: OrderIso.map_atTop
code: @[simp]
theorem map_atTop (e : α ≃o β) : map (e : α → β) atTop = atTop 
goal: Filter.map (⇑e) Filter.atTop = Filter.atTop

full_name: OrderIso.map_atBot
code: @[simp]
theorem map_atBot (e : α ≃o β) : map (e : α → β) atBot = atBot 
goal: Filter.map (⇑e) Filter.atBot = Filter.atBot

full_name: OrderIso.tendsto_atTop
code: theorem tendsto_atTop (e : α ≃o β) : Tendsto e atTop atTop 
goal: Filter.Tendsto (⇑e) Filter.atTop Filter.atTop

full_name: OrderIso.tendsto_atBot
code: theorem tendsto_atBot (e : α ≃o β) : Tendsto e atBot atBot 
goal: Filter.Tendsto (⇑e) Filter.atBot Filter.atBot

full_name: OrderIso.tendsto_atTop_iff
code: @[simp]
theorem tendsto_atTop_iff {l : Filter γ} {f : γ → α} (e : α ≃o β) :
    Tendsto (fun x => e (f x)) l atTop ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => e (f x)) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop

full_name: OrderIso.tendsto_atBot_iff
code: @[simp]
theorem tendsto_atBot_iff {l : Filter γ} {f : γ → α} (e : α ≃o β) :
    Tendsto (fun x => e (f x)) l atBot ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => e (f x)) l Filter.atBot ↔ Filter.Tendsto f l Filter.atBot

full_name: Filter.inf_map_atTop_neBot_iff
code: theorem inf_map_atTop_neBot_iff [SemilatticeSup α] [Nonempty α] {F : Filter β} {u : α → β} :
    NeBot (F ⊓ map u atTop) ↔ ∀ U ∈ F, ∀ N, ∃ n ≥ N, u n ∈ U 
goal: (F ⊓ Filter.map u Filter.atTop).NeBot ↔ ∀ U ∈ F, ∀ (N : α), ∃ n ≥ N, u n ∈ U

full_name: Filter.inf_map_atBot_neBot_iff
code: theorem inf_map_atBot_neBot_iff [SemilatticeInf α] [Nonempty α] {F : Filter β} {u : α → β} :
    NeBot (F ⊓ map u atBot) ↔ ∀ U ∈ F, ∀ N, ∃ n ≤ N, u n ∈ U 
goal: (F ⊓ Filter.map u Filter.atBot).NeBot ↔ ∀ U ∈ F, ∀ (N : α), ∃ n ≤ N, u n ∈ U

full_name: Filter.extraction_of_frequently_atTop'
code: theorem extraction_of_frequently_atTop' {P : ℕ → Prop} (h : ∀ N, ∃ n > N, P n) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ ∀ n, P (φ n) 
goal: ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)

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

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

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

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

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

full_name: Filter.Eventually.atTop_of_arithmetic
code: 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 
goal: ∀ᶠ (a : ℕ) in Filter.atTop, p a

full_name: Filter.exists_le_of_tendsto_atTop
code: theorem exists_le_of_tendsto_atTop [SemilatticeSup α] [Preorder β] {u : α → β}
    (h : Tendsto u atTop atTop) (a : α) (b : β) : ∃ a' ≥ a, b ≤ u a' 
goal: ∃ a' ≥ a, b ≤ u a'

full_name: Filter.exists_le_of_tendsto_atBot
code: theorem exists_le_of_tendsto_atBot [SemilatticeSup α] [Preorder β] {u : α → β}
    (h : Tendsto u atTop atBot) : ∀ a b, ∃ a' ≥ a, u a' ≤ b 
goal: ∃ a' ≥ a, u a' ≤ b

full_name: Filter.exists_lt_of_tendsto_atTop
code: theorem exists_lt_of_tendsto_atTop [SemilatticeSup α] [Preorder β] [NoMaxOrder β] {u : α → β}
    (h : Tendsto u atTop atTop) (a : α) (b : β) : ∃ a' ≥ a, b < u a' 
goal: ∃ a' ≥ a, b < u a'

full_name: Filter.exists_lt_of_tendsto_atBot
code: theorem exists_lt_of_tendsto_atBot [SemilatticeSup α] [Preorder β] [NoMinOrder β] {u : α → β}
    (h : Tendsto u atTop atBot) : ∀ a b, ∃ a' ≥ a, u a' < b 
goal: ∃ a' ≥ a, u a' < b

full_name: Filter.high_scores
code: /-- If `u` is a sequence which is unbounded above,
then after any point, it reaches a value strictly greater than all previous values.
-/
theorem high_scores [LinearOrder β] [NoMaxOrder β] {u : ℕ → β} (hu : Tendsto u atTop atTop) :
    ∀ N, ∃ n ≥ N, ∀ k < n, u k < u n 
goal: ∃ n ≥ N, ∀ k < n, u k < u n

full_name: Filter.low_scores
code: /-- If `u` is a sequence which is unbounded below,
then after any point, it reaches a value strictly smaller than all previous values.
-/
-- @[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 
goal: ∃ n ≥ N, ∀ k < n, u n < u k

full_name: Filter.frequently_high_scores
code: /-- If `u` is a sequence which is unbounded above,
then it `Frequently` reaches a value strictly greater than all previous values.
-/
theorem frequently_high_scores [LinearOrder β] [NoMaxOrder β] {u : ℕ → β}
    (hu : Tendsto u atTop atTop) : ∃ᶠ n in atTop, ∀ k < n, u k < u n 
goal: ∃ᶠ (n : ℕ) in Filter.atTop, ∀ k < n, u k < u n

full_name: Filter.frequently_low_scores
code: /-- If `u` is a sequence which is unbounded below,
then it `Frequently` reaches a value strictly smaller than all previous values.
-/
theorem frequently_low_scores [LinearOrder β] [NoMinOrder β] {u : ℕ → β}
    (hu : Tendsto u atTop atBot) : ∃ᶠ n in atTop, ∀ k < n, u n < u k 
goal: ∃ᶠ (n : ℕ) in Filter.atTop, ∀ k < n, u n < u k

full_name: Filter.strictMono_subseq_of_tendsto_atTop
code: theorem strictMono_subseq_of_tendsto_atTop [LinearOrder β] [NoMaxOrder β] {u : ℕ → β}
    (hu : Tendsto u atTop atTop) : ∃ φ : ℕ → ℕ, StrictMono φ ∧ StrictMono (u ∘ φ) 
goal: ∃ φ, StrictMono φ ∧ StrictMono (u ∘ φ)

full_name: Filter.strictMono_subseq_of_id_le
code: theorem strictMono_subseq_of_id_le {u : ℕ → ℕ} (hu : ∀ n, n ≤ u n) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ StrictMono (u ∘ φ) 
goal: ∃ φ, StrictMono φ ∧ StrictMono (u ∘ φ)

full_name: StrictMono.tendsto_atTop
code: theorem _root_.StrictMono.tendsto_atTop {φ : ℕ → ℕ} (h : StrictMono φ) : Tendsto φ atTop atTop 
goal: Filter.Tendsto φ Filter.atTop Filter.atTop

full_name: Filter.tendsto_atTop_add_nonneg_left'
code: 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 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop

full_name: Filter.tendsto_atBot_add_nonpos_left'
code: 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 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot

full_name: Filter.tendsto_atTop_add_nonneg_left
code: 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 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop

full_name: Filter.tendsto_atBot_add_nonpos_left
code: 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 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot

full_name: Filter.tendsto_atTop_add_nonneg_right'
code: 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 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop

full_name: Filter.tendsto_atBot_add_nonpos_right'
code: 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 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot

full_name: Filter.tendsto_atTop_add_nonneg_right
code: 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 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop

full_name: Filter.tendsto_atBot_add_nonpos_right
code: 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 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot

full_name: Filter.tendsto_atTop_add
code: theorem tendsto_atTop_add (hf : Tendsto f l atTop) (hg : Tendsto g l atTop) :
    Tendsto (fun x => f x + g x) l atTop 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop

full_name: Filter.tendsto_atBot_add
code: theorem tendsto_atBot_add (hf : Tendsto f l atBot) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x + g x) l atBot 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot

full_name: Filter.Tendsto.nsmul_atTop
code: theorem Tendsto.nsmul_atTop (hf : Tendsto f l atTop) {n : ℕ} (hn : 0 < n) :
    Tendsto (fun x => n • f x) l atTop 
goal: Filter.Tendsto (fun x => n • f x) l Filter.atTop

full_name: Filter.Tendsto.nsmul_atBot
code: theorem Tendsto.nsmul_atBot (hf : Tendsto f l atBot) {n : ℕ} (hn : 0 < n) :
    Tendsto (fun x => n • f x) l atBot 
goal: Filter.Tendsto (fun x => n • f x) l Filter.atBot

full_name: Filter.tendsto_atTop_of_add_const_left
code: theorem tendsto_atTop_of_add_const_left (C : β) (hf : Tendsto (fun x => C + f x) l atTop) :
    Tendsto f l atTop 
goal: Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_atBot_of_add_const_left
code: theorem tendsto_atBot_of_add_const_left (C : β) (hf : Tendsto (fun x => C + f x) l atBot) :
    Tendsto f l atBot 
goal: Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_atTop_of_add_const_right
code: theorem tendsto_atTop_of_add_const_right (C : β) (hf : Tendsto (fun x => f x + C) l atTop) :
    Tendsto f l atTop 
goal: Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_atBot_of_add_const_right
code: theorem tendsto_atBot_of_add_const_right (C : β) (hf : Tendsto (fun x => f x + C) l atBot) :
    Tendsto f l atBot 
goal: Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_atTop_of_add_bdd_above_left'
code: theorem tendsto_atTop_of_add_bdd_above_left' (C) (hC : ∀ᶠ x in l, f x ≤ C)
    (h : Tendsto (fun x => f x + g x) l atTop) : Tendsto g l atTop 
goal: Filter.Tendsto g l Filter.atTop

full_name: Filter.tendsto_atBot_of_add_bdd_below_left'
code: theorem tendsto_atBot_of_add_bdd_below_left' (C) (hC : ∀ᶠ x in l, C ≤ f x)
    (h : Tendsto (fun x => f x + g x) l atBot) : Tendsto g l atBot 
goal: Filter.Tendsto g l Filter.atBot

full_name: Filter.tendsto_atTop_of_add_bdd_above_left
code: theorem tendsto_atTop_of_add_bdd_above_left (C) (hC : ∀ x, f x ≤ C) :
    Tendsto (fun x => f x + g x) l atTop → Tendsto g l atTop 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop → Filter.Tendsto g l Filter.atTop

full_name: Filter.tendsto_atBot_of_add_bdd_below_left
code: theorem tendsto_atBot_of_add_bdd_below_left (C) (hC : ∀ x, C ≤ f x) :
    Tendsto (fun x => f x + g x) l atBot → Tendsto g l atBot 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot → Filter.Tendsto g l Filter.atBot

full_name: Filter.tendsto_atTop_of_add_bdd_above_right'
code: theorem tendsto_atTop_of_add_bdd_above_right' (C) (hC : ∀ᶠ x in l, g x ≤ C)
    (h : Tendsto (fun x => f x + g x) l atTop) : Tendsto f l atTop 
goal: Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_atBot_of_add_bdd_below_right'
code: theorem tendsto_atBot_of_add_bdd_below_right' (C) (hC : ∀ᶠ x in l, C ≤ g x)
    (h : Tendsto (fun x => f x + g x) l atBot) : Tendsto f l atBot 
goal: Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_atTop_of_add_bdd_above_right
code: theorem tendsto_atTop_of_add_bdd_above_right (C) (hC : ∀ x, g x ≤ C) :
    Tendsto (fun x => f x + g x) l atTop → Tendsto f l atTop 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop → Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_atBot_of_add_bdd_below_right
code: theorem tendsto_atBot_of_add_bdd_below_right (C) (hC : ∀ x, C ≤ g x) :
    Tendsto (fun x => f x + g x) l atBot → Tendsto f l atBot 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot → Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_atTop_add_left_of_le'
code: theorem tendsto_atTop_add_left_of_le' (C : β) (hf : ∀ᶠ x in l, C ≤ f x) (hg : Tendsto g l atTop) :
    Tendsto (fun x => f x + g x) l atTop 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop

full_name: Filter.tendsto_atBot_add_left_of_ge'
code: theorem tendsto_atBot_add_left_of_ge' (C : β) (hf : ∀ᶠ x in l, f x ≤ C) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x + g x) l atBot 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot

full_name: Filter.tendsto_atTop_add_left_of_le
code: theorem tendsto_atTop_add_left_of_le (C : β) (hf : ∀ x, C ≤ f x) (hg : Tendsto g l atTop) :
    Tendsto (fun x => f x + g x) l atTop 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop

full_name: Filter.tendsto_atBot_add_left_of_ge
code: theorem tendsto_atBot_add_left_of_ge (C : β) (hf : ∀ x, f x ≤ C) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x + g x) l atBot 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot

full_name: Filter.tendsto_atTop_add_right_of_le'
code: theorem tendsto_atTop_add_right_of_le' (C : β) (hf : Tendsto f l atTop) (hg : ∀ᶠ x in l, C ≤ g x) :
    Tendsto (fun x => f x + g x) l atTop 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop

full_name: Filter.tendsto_atBot_add_right_of_ge'
code: theorem tendsto_atBot_add_right_of_ge' (C : β) (hf : Tendsto f l atBot) (hg : ∀ᶠ x in l, g x ≤ C) :
    Tendsto (fun x => f x + g x) l atBot 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot

full_name: Filter.tendsto_atTop_add_right_of_le
code: theorem tendsto_atTop_add_right_of_le (C : β) (hf : Tendsto f l atTop) (hg : ∀ x, C ≤ g x) :
    Tendsto (fun x => f x + g x) l atTop 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atTop

full_name: Filter.tendsto_atBot_add_right_of_ge
code: theorem tendsto_atBot_add_right_of_ge (C : β) (hf : Tendsto f l atBot) (hg : ∀ x, g x ≤ C) :
    Tendsto (fun x => f x + g x) l atBot 
goal: Filter.Tendsto (fun x => f x + g x) l Filter.atBot

full_name: Filter.tendsto_atTop_add_const_left
code: theorem tendsto_atTop_add_const_left (C : β) (hf : Tendsto f l atTop) :
    Tendsto (fun x => C + f x) l atTop 
goal: Filter.Tendsto (fun x => C + f x) l Filter.atTop

full_name: Filter.tendsto_atBot_add_const_left
code: theorem tendsto_atBot_add_const_left (C : β) (hf : Tendsto f l atBot) :
    Tendsto (fun x => C + f x) l atBot 
goal: Filter.Tendsto (fun x => C + f x) l Filter.atBot

full_name: Filter.tendsto_atTop_add_const_right
code: theorem tendsto_atTop_add_const_right (C : β) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x + C) l atTop 
goal: Filter.Tendsto (fun x => f x + C) l Filter.atTop

full_name: Filter.tendsto_atBot_add_const_right
code: theorem tendsto_atBot_add_const_right (C : β) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x + C) l atBot 
goal: Filter.Tendsto (fun x => f x + C) l Filter.atBot

full_name: Filter.map_neg_atBot
code: theorem map_neg_atBot : map (Neg.neg : β → β) atBot = atTop 
goal: Filter.map Neg.neg Filter.atBot = Filter.atTop

full_name: Filter.map_neg_atTop
code: theorem map_neg_atTop : map (Neg.neg : β → β) atTop = atBot 
goal: Filter.map Neg.neg Filter.atTop = Filter.atBot

full_name: Filter.comap_neg_atBot
code: theorem comap_neg_atBot : comap (Neg.neg : β → β) atBot = atTop 
goal: Filter.comap Neg.neg Filter.atBot = Filter.atTop

full_name: Filter.comap_neg_atTop
code: theorem comap_neg_atTop : comap (Neg.neg : β → β) atTop = atBot 
goal: Filter.comap Neg.neg Filter.atTop = Filter.atBot

full_name: Filter.tendsto_neg_atTop_atBot
code: theorem tendsto_neg_atTop_atBot : Tendsto (Neg.neg : β → β) atTop atBot 
goal: Filter.Tendsto Neg.neg Filter.atTop Filter.atBot

full_name: Filter.tendsto_neg_atBot_atTop
code: theorem tendsto_neg_atBot_atTop : Tendsto (Neg.neg : β → β) atBot atTop 
goal: Filter.Tendsto Neg.neg Filter.atBot Filter.atTop

full_name: Filter.tendsto_neg_atTop_iff
code: @[simp]
theorem tendsto_neg_atTop_iff : Tendsto (fun x => -f x) l atTop ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => -f x) l Filter.atTop ↔ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_neg_atBot_iff
code: @[simp]
theorem tendsto_neg_atBot_iff : Tendsto (fun x => -f x) l atBot ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => -f x) l Filter.atBot ↔ Filter.Tendsto f l Filter.atTop

full_name: Filter.Tendsto.atTop_mul_atTop
code: theorem Tendsto.atTop_mul_atTop (hf : Tendsto f l atTop) (hg : Tendsto g l atTop) :
    Tendsto (fun x => f x * g x) l atTop 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atTop

full_name: Filter.tendsto_mul_self_atTop
code: theorem tendsto_mul_self_atTop : Tendsto (fun x : α => x * x) atTop atTop 
goal: Filter.Tendsto (fun x => x * x) Filter.atTop Filter.atTop

full_name: Filter.tendsto_pow_atTop
code: /-- The monomial function `x^n` tends to `+∞` at `+∞` for any positive natural `n`.
A version for positive real powers exists as `tendsto_rpow_atTop`. -/
theorem tendsto_pow_atTop {n : ℕ} (hn : n ≠ 0) : Tendsto (fun x : α => x ^ n) atTop atTop 
goal: Filter.Tendsto (fun x => x ^ n) Filter.atTop Filter.atTop

full_name: Filter.zero_pow_eventuallyEq
code: theorem zero_pow_eventuallyEq [MonoidWithZero α] :
    (fun n : ℕ => (0 : α) ^ n) =ᶠ[atTop] fun _ => 0 
goal: (fun n => 0 ^ n) =ᶠ[Filter.atTop] fun x => 0

full_name: Filter.Tendsto.atTop_mul_atBot
code: theorem Tendsto.atTop_mul_atBot (hf : Tendsto f l atTop) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x * g x) l atBot 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atBot

full_name: Filter.Tendsto.atBot_mul_atTop
code: theorem Tendsto.atBot_mul_atTop (hf : Tendsto f l atBot) (hg : Tendsto g l atTop) :
    Tendsto (fun x => f x * g x) l atBot 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atBot

full_name: Filter.Tendsto.atBot_mul_atBot
code: theorem Tendsto.atBot_mul_atBot (hf : Tendsto f l atBot) (hg : Tendsto g l atBot) :
    Tendsto (fun x => f x * g x) l atTop 
goal: Filter.Tendsto (fun x => f x * g x) l Filter.atTop

full_name: Filter.tendsto_abs_atTop_atTop
code: /-- $\lim_{x\to+\infty}|x|=+\infty$ -/
theorem tendsto_abs_atTop_atTop : Tendsto (abs : α → α) atTop atTop 
goal: Filter.Tendsto abs Filter.atTop Filter.atTop

full_name: Filter.tendsto_abs_atBot_atTop
code: /-- $\lim_{x\to-\infty}|x|=+\infty$ -/
theorem tendsto_abs_atBot_atTop : Tendsto (abs : α → α) atBot atTop 
goal: Filter.Tendsto abs Filter.atBot Filter.atTop

full_name: Filter.comap_abs_atTop
code: @[simp]
theorem comap_abs_atTop : comap (abs : α → α) atTop = atBot ⊔ atTop 
goal: Filter.comap abs Filter.atTop = Filter.atBot ⊔ Filter.atTop

full_name: Filter.Tendsto.atTop_of_const_mul
code: theorem Tendsto.atTop_of_const_mul {c : α} (hc : 0 < c) (hf : Tendsto (fun x => c * f x) l atTop) :
    Tendsto f l atTop 
goal: Filter.Tendsto f l Filter.atTop

full_name: Filter.Tendsto.atTop_of_mul_const
code: theorem Tendsto.atTop_of_mul_const {c : α} (hc : 0 < c) (hf : Tendsto (fun x => f x * c) l atTop) :
    Tendsto f l atTop 
goal: Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_pow_atTop_iff
code: @[simp]
theorem tendsto_pow_atTop_iff {n : ℕ} : Tendsto (fun x : α => x ^ n) atTop atTop ↔ n ≠ 0 
goal: Filter.Tendsto (fun x => x ^ n) Filter.atTop Filter.atTop ↔ n ≠ 0

full_name: Filter.not_tendsto_pow_atTop_atBot
code: theorem not_tendsto_pow_atTop_atBot [LinearOrderedRing α] :
    ∀ {n : ℕ}, ¬Tendsto (fun x : α => x ^ n) atTop atBot
  
goal: ¬Filter.Tendsto (fun x => x ^ n) Filter.atTop Filter.atBot

full_name: Filter.tendsto_const_mul_atTop_of_pos
code: /-- If `r` is a positive constant, `fun x ↦ r * f x` tends to infinity along a filter
if and only if `f` tends to infinity along the same filter. -/
theorem tendsto_const_mul_atTop_of_pos (hr : 0 < r) :
    Tendsto (fun x => r * f x) l atTop ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_mul_const_atTop_of_pos
code: /-- If `r` is a positive constant, `fun x ↦ f x * r` tends to infinity along a filter
if and only if `f` tends to infinity along the same filter. -/
theorem tendsto_mul_const_atTop_of_pos (hr : 0 < r) :
    Tendsto (fun x => f x * r) l atTop ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_div_const_atTop_of_pos
code: /-- If `r` is a positive constant, `x ↦ f x / r` tends to infinity along a filter
if and only if `f` tends to infinity along the same filter. -/
lemma tendsto_div_const_atTop_of_pos (hr : 0 < r) :
    Tendsto (fun x ↦ f x / r) l atTop ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_const_mul_atTop_iff_pos
code: /-- If `f` tends to infinity along a nontrivial filter `l`, then
`fun x ↦ r * f x` tends to infinity if and only if `0 < r. `-/
theorem tendsto_const_mul_atTop_iff_pos [NeBot l] (h : Tendsto f l atTop) :
    Tendsto (fun x => r * f x) l atTop ↔ 0 < r 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atTop ↔ 0 < r

full_name: Filter.tendsto_mul_const_atTop_iff_pos
code: /-- If `f` tends to infinity along a nontrivial filter `l`, then
`fun x ↦ f x * r` tends to infinity if and only if `0 < r. `-/
theorem tendsto_mul_const_atTop_iff_pos [NeBot l] (h : Tendsto f l atTop) :
    Tendsto (fun x => f x * r) l atTop ↔ 0 < r 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atTop ↔ 0 < r

full_name: Filter.tendsto_div_const_atTop_iff_pos
code: /-- If `f` tends to infinity along a nontrivial filter `l`, then
`x ↦ f x * r` tends to infinity if and only if `0 < r. `-/
lemma tendsto_div_const_atTop_iff_pos [NeBot l] (h : Tendsto f l atTop) :
    Tendsto (fun x ↦ f x / r) l atTop ↔ 0 < r 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atTop ↔ 0 < r

full_name: Filter.Tendsto.const_mul_atTop
code: /-- If `f` tends to infinity along a filter, then `f` multiplied by a positive
constant (on the left) also tends to infinity. For a version working in `ℕ` or `ℤ`, use
`Filter.Tendsto.const_mul_atTop'` instead. -/
theorem Tendsto.const_mul_atTop (hr : 0 < r) (hf : Tendsto f l atTop) :
    Tendsto (fun x => r * f x) l atTop 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atTop

full_name: Filter.Tendsto.atTop_mul_const
code: /-- If a function `f` tends to infinity along a filter, then `f` multiplied by a positive
constant (on the right) also tends to infinity. For a version working in `ℕ` or `ℤ`, use
`Filter.Tendsto.atTop_mul_const'` instead. -/
theorem Tendsto.atTop_mul_const (hr : 0 < r) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x * r) l atTop 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atTop

full_name: Filter.Tendsto.atTop_div_const
code: /-- If a function `f` tends to infinity along a filter, then `f` divided by a positive
constant also tends to infinity. -/
theorem Tendsto.atTop_div_const (hr : 0 < r) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x / r) l atTop 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atTop

full_name: Filter.tendsto_const_mul_pow_atTop
code: theorem tendsto_const_mul_pow_atTop (hn : n ≠ 0) (hc : 0 < c) :
    Tendsto (fun x => c * x ^ n) atTop atTop 
goal: Filter.Tendsto (fun x => c * x ^ n) Filter.atTop Filter.atTop

full_name: Filter.tendsto_const_mul_pow_atTop_iff
code: theorem tendsto_const_mul_pow_atTop_iff :
    Tendsto (fun x => c * x ^ n) atTop atTop ↔ n ≠ 0 ∧ 0 < c 
goal: Filter.Tendsto (fun x => c * x ^ n) Filter.atTop Filter.atTop ↔ n ≠ 0 ∧ 0 < c

full_name: Filter.tendsto_zpow_atTop_atTop
code: lemma tendsto_zpow_atTop_atTop {n : ℤ} (hn : 0 < n) : Tendsto (fun x : α ↦ x ^ n) atTop atTop 
goal: Filter.Tendsto (fun x => x ^ n) Filter.atTop Filter.atTop

full_name: Filter.tendsto_const_mul_atBot_of_pos
code: /-- If `r` is a positive constant, `fun x ↦ r * f x` tends to negative infinity along a filter
if and only if `f` tends to negative infinity along the same filter. -/
theorem tendsto_const_mul_atBot_of_pos (hr : 0 < r) :
    Tendsto (fun x => r * f x) l atBot ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atBot ↔ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_mul_const_atBot_of_pos
code: /-- If `r` is a positive constant, `fun x ↦ f x * r` tends to negative infinity along a filter
if and only if `f` tends to negative infinity along the same filter. -/
theorem tendsto_mul_const_atBot_of_pos (hr : 0 < r) :
    Tendsto (fun x => f x * r) l atBot ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atBot ↔ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_div_const_atBot_of_pos
code: /-- If `r` is a positive constant, `fun x ↦ f x / r` tends to negative infinity along a filter
if and only if `f` tends to negative infinity along the same filter. -/
lemma tendsto_div_const_atBot_of_pos (hr : 0 < r) :
    Tendsto (fun x ↦ f x / r) l atBot ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atBot ↔ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_const_mul_atTop_of_neg
code: /-- If `r` is a negative constant, `fun x ↦ r * f x` tends to infinity along a filter `l`
if and only if `f` tends to negative infinity along `l`. -/
theorem tendsto_const_mul_atTop_of_neg (hr : r < 0) :
    Tendsto (fun x => r * f x) l atTop ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atTop ↔ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_mul_const_atTop_of_neg
code: /-- If `r` is a negative constant, `fun x ↦ f x * r` tends to infinity along a filter `l`
if and only if `f` tends to negative infinity along `l`. -/
theorem tendsto_mul_const_atTop_of_neg (hr : r < 0) :
    Tendsto (fun x => f x * r) l atTop ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atTop ↔ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_div_const_atTop_of_neg
code: /-- If `r` is a negative constant, `fun x ↦ f x / r` tends to infinity along a filter `l`
if and only if `f` tends to negative infinity along `l`. -/
lemma tendsto_div_const_atTop_of_neg (hr : r < 0) :
    Tendsto (fun x ↦ f x / r) l atTop ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atTop ↔ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_const_mul_atBot_of_neg
code: /-- If `r` is a negative constant, `fun x ↦ r * f x` tends to negative infinity along a filter `l`
if and only if `f` tends to infinity along `l`. -/
theorem tendsto_const_mul_atBot_of_neg (hr : r < 0) :
    Tendsto (fun x => r * f x) l atBot ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atBot ↔ Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_mul_const_atBot_of_neg
code: /-- If `r` is a negative constant, `fun x ↦ f x * r` tends to negative infinity along a filter `l`
if and only if `f` tends to infinity along `l`. -/
theorem tendsto_mul_const_atBot_of_neg (hr : r < 0) :
    Tendsto (fun x => f x * r) l atBot ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atBot ↔ Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_div_const_atBot_of_neg
code: /-- If `r` is a negative constant, `fun x ↦ f x / r` tends to negative infinity along a filter `l`
if and only if `f` tends to infinity along `l`. -/
lemma tendsto_div_const_atBot_of_neg (hr : r < 0) :
    Tendsto (fun x ↦ f x / r) l atBot ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atBot ↔ Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_const_mul_atTop_iff
code: /-- The function `fun x ↦ r * f x` tends to infinity along a nontrivial filter
if and only if `r > 0` and `f` tends to infinity or `r < 0` and `f` tends to negative infinity. -/
theorem tendsto_const_mul_atTop_iff [NeBot l] :
    Tendsto (fun x => r * f x) l atTop ↔ 0 < r ∧ Tendsto f l atTop ∨ r < 0 ∧ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atTop ↔
  0 < r ∧ Filter.Tendsto f l Filter.atTop ∨ r < 0 ∧ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_mul_const_atTop_iff
code: /-- The function `fun x ↦ f x * r` tends to infinity along a nontrivial filter
if and only if `r > 0` and `f` tends to infinity or `r < 0` and `f` tends to negative infinity. -/
theorem tendsto_mul_const_atTop_iff [NeBot l] :
    Tendsto (fun x => f x * r) l atTop ↔ 0 < r ∧ Tendsto f l atTop ∨ r < 0 ∧ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atTop ↔
  0 < r ∧ Filter.Tendsto f l Filter.atTop ∨ r < 0 ∧ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_div_const_atTop_iff
code: /-- The function `fun x ↦ f x / r` tends to infinity along a nontrivial filter
if and only if `r > 0` and `f` tends to infinity or `r < 0` and `f` tends to negative infinity. -/
lemma tendsto_div_const_atTop_iff [NeBot l] :
    Tendsto (fun x ↦ f x / r) l atTop ↔ 0 < r ∧ Tendsto f l atTop ∨ r < 0 ∧ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atTop ↔
  0 < r ∧ Filter.Tendsto f l Filter.atTop ∨ r < 0 ∧ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_const_mul_atBot_iff
code: /-- The function `fun x ↦ r * f x` tends to negative infinity along a nontrivial filter
if and only if `r > 0` and `f` tends to negative infinity or `r < 0` and `f` tends to infinity. -/
theorem tendsto_const_mul_atBot_iff [NeBot l] :
    Tendsto (fun x => r * f x) l atBot ↔ 0 < r ∧ Tendsto f l atBot ∨ r < 0 ∧ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atBot ↔
  0 < r ∧ Filter.Tendsto f l Filter.atBot ∨ r < 0 ∧ Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_mul_const_atBot_iff
code: /-- The function `fun x ↦ f x * r` tends to negative infinity along a nontrivial filter
if and only if `r > 0` and `f` tends to negative infinity or `r < 0` and `f` tends to infinity. -/
theorem tendsto_mul_const_atBot_iff [NeBot l] :
    Tendsto (fun x => f x * r) l atBot ↔ 0 < r ∧ Tendsto f l atBot ∨ r < 0 ∧ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atBot ↔
  0 < r ∧ Filter.Tendsto f l Filter.atBot ∨ r < 0 ∧ Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_div_const_atBot_iff
code: /-- The function `fun x ↦ f x / r` tends to negative infinity along a nontrivial filter
if and only if `r > 0` and `f` tends to negative infinity or `r < 0` and `f` tends to infinity. -/
lemma tendsto_div_const_atBot_iff [NeBot l] :
    Tendsto (fun x ↦ f x / r) l atBot ↔ 0 < r ∧ Tendsto f l atBot ∨ r < 0 ∧ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atBot ↔
  0 < r ∧ Filter.Tendsto f l Filter.atBot ∨ r < 0 ∧ Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_const_mul_atTop_iff_neg
code: /-- If `f` tends to negative infinity along a nontrivial filter `l`,
then `fun x ↦ r * f x` tends to infinity if and only if `r < 0. `-/
theorem tendsto_const_mul_atTop_iff_neg [NeBot l] (h : Tendsto f l atBot) :
    Tendsto (fun x => r * f x) l atTop ↔ r < 0 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atTop ↔ r < 0

full_name: Filter.tendsto_mul_const_atTop_iff_neg
code: /-- If `f` tends to negative infinity along a nontrivial filter `l`,
then `fun x ↦ f x * r` tends to infinity if and only if `r < 0. `-/
theorem tendsto_mul_const_atTop_iff_neg [NeBot l] (h : Tendsto f l atBot) :
    Tendsto (fun x => f x * r) l atTop ↔ r < 0 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atTop ↔ r < 0

full_name: Filter.tendsto_div_const_atTop_iff_neg
code: /-- If `f` tends to negative infinity along a nontrivial filter `l`,
then `fun x ↦ f x / r` tends to infinity if and only if `r < 0. `-/
lemma tendsto_div_const_atTop_iff_neg [NeBot l] (h : Tendsto f l atBot) :
    Tendsto (fun x ↦ f x / r) l atTop ↔ r < 0 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atTop ↔ r < 0

full_name: Filter.tendsto_const_mul_atBot_iff_pos
code: /-- If `f` tends to negative infinity along a nontrivial filter `l`, then
`fun x ↦ r * f x` tends to negative infinity if and only if `0 < r. `-/
theorem tendsto_const_mul_atBot_iff_pos [NeBot l] (h : Tendsto f l atBot) :
    Tendsto (fun x => r * f x) l atBot ↔ 0 < r 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atBot ↔ 0 < r

full_name: Filter.tendsto_mul_const_atBot_iff_pos
code: /-- If `f` tends to negative infinity along a nontrivial filter `l`, then
`fun x ↦ f x * r` tends to negative infinity if and only if `0 < r. `-/
theorem tendsto_mul_const_atBot_iff_pos [NeBot l] (h : Tendsto f l atBot) :
    Tendsto (fun x => f x * r) l atBot ↔ 0 < r 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atBot ↔ 0 < r

full_name: Filter.tendsto_div_const_atBot_iff_pos
code: /-- If `f` tends to negative infinity along a nontrivial filter `l`, then
`fun x ↦ f x / r` tends to negative infinity if and only if `0 < r. `-/
lemma tendsto_div_const_atBot_iff_pos [NeBot l] (h : Tendsto f l atBot) :
    Tendsto (fun x ↦ f x / r) l atBot ↔ 0 < r 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atBot ↔ 0 < r

full_name: Filter.tendsto_const_mul_atBot_iff_neg
code: /-- If `f` tends to infinity along a nontrivial filter,
`fun x ↦ r * f x` tends to negative infinity if and only if `r < 0. `-/
theorem tendsto_const_mul_atBot_iff_neg [NeBot l] (h : Tendsto f l atTop) :
    Tendsto (fun x => r * f x) l atBot ↔ r < 0 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atBot ↔ r < 0

full_name: Filter.tendsto_mul_const_atBot_iff_neg
code: /-- If `f` tends to infinity along a nontrivial filter,
`fun x ↦ f x * r` tends to negative infinity if and only if `r < 0. `-/
theorem tendsto_mul_const_atBot_iff_neg [NeBot l] (h : Tendsto f l atTop) :
    Tendsto (fun x => f x * r) l atBot ↔ r < 0 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atBot ↔ r < 0

full_name: Filter.tendsto_div_const_atBot_iff_neg
code: /-- If `f` tends to infinity along a nontrivial filter,
`fun x ↦ f x / r` tends to negative infinity if and only if `r < 0. `-/
lemma tendsto_div_const_atBot_iff_neg [NeBot l] (h : Tendsto f l atTop) :
    Tendsto (fun x ↦ f x / r) l atBot ↔ r < 0 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atBot ↔ r < 0

full_name: Filter.Tendsto.const_mul_atTop_of_neg
code: /-- If a function `f` tends to infinity along a filter,
then `f` multiplied by a negative constant (on the left) tends to negative infinity. -/
theorem Tendsto.const_mul_atTop_of_neg (hr : r < 0) (hf : Tendsto f l atTop) :
    Tendsto (fun x => r * f x) l atBot 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atBot

full_name: Filter.Tendsto.atTop_mul_const_of_neg
code: /-- If a function `f` tends to infinity along a filter,
then `f` multiplied by a negative constant (on the right) tends to negative infinity. -/
theorem Tendsto.atTop_mul_const_of_neg (hr : r < 0) (hf : Tendsto f l atTop) :
    Tendsto (fun x => f x * r) l atBot 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atBot

full_name: Filter.Tendsto.atTop_div_const_of_neg
code: /-- If a function `f` tends to infinity along a filter,
then `f` divided by a negative constant tends to negative infinity. -/
lemma Tendsto.atTop_div_const_of_neg (hr : r < 0) (hf : Tendsto f l atTop) :
    Tendsto (fun x ↦ f x / r) l atBot 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atBot

full_name: Filter.Tendsto.const_mul_atBot
code: /-- If a function `f` tends to negative infinity along a filter, then `f` multiplied by
a positive constant (on the left) also tends to negative infinity. -/
theorem Tendsto.const_mul_atBot (hr : 0 < r) (hf : Tendsto f l atBot) :
    Tendsto (fun x => r * f x) l atBot 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atBot

full_name: Filter.Tendsto.atBot_mul_const
code: /-- If a function `f` tends to negative infinity along a filter, then `f` multiplied by
a positive constant (on the right) also tends to negative infinity. -/
theorem Tendsto.atBot_mul_const (hr : 0 < r) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x * r) l atBot 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atBot

full_name: Filter.Tendsto.atBot_div_const
code: /-- If a function `f` tends to negative infinity along a filter, then `f` divided by
a positive constant also tends to negative infinity. -/
theorem Tendsto.atBot_div_const (hr : 0 < r) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x / r) l atBot 
goal: Filter.Tendsto (fun x => f x / r) l Filter.atBot

full_name: Filter.Tendsto.const_mul_atBot_of_neg
code: /-- If a function `f` tends to negative infinity along a filter,
then `f` multiplied by a negative constant (on the left) tends to positive infinity. -/
theorem Tendsto.const_mul_atBot_of_neg (hr : r < 0) (hf : Tendsto f l atBot) :
    Tendsto (fun x => r * f x) l atTop 
goal: Filter.Tendsto (fun x => r * f x) l Filter.atTop

full_name: Filter.Tendsto.atBot_mul_const_of_neg
code: /-- If a function tends to negative infinity along a filter,
then `f` multiplied by a negative constant (on the right) tends to positive infinity. -/
theorem Tendsto.atBot_mul_const_of_neg (hr : r < 0) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x * r) l atTop 
goal: Filter.Tendsto (fun x => f x * r) l Filter.atTop

full_name: Filter.tendsto_neg_const_mul_pow_atTop
code: theorem tendsto_neg_const_mul_pow_atTop {c : α} {n : ℕ} (hn : n ≠ 0) (hc : c < 0) :
    Tendsto (fun x => c * x ^ n) atTop atBot 
goal: Filter.Tendsto (fun x => c * x ^ n) Filter.atTop Filter.atBot

full_name: Filter.tendsto_const_mul_pow_atBot_iff
code: theorem tendsto_const_mul_pow_atBot_iff {c : α} {n : ℕ} :
    Tendsto (fun x => c * x ^ n) atTop atBot ↔ n ≠ 0 ∧ c < 0 
goal: Filter.Tendsto (fun x => c * x ^ n) Filter.atTop Filter.atBot ↔ n ≠ 0 ∧ c < 0

full_name: Filter.tendsto_atTop'
code: theorem tendsto_atTop' [Nonempty α] [SemilatticeSup α] {f : α → β} {l : Filter β} :
    Tendsto f atTop l ↔ ∀ s ∈ l, ∃ a, ∀ b ≥ a, f b ∈ s 
goal: Filter.Tendsto f Filter.atTop l ↔ ∀ s ∈ l, ∃ a, ∀ b ≥ a, f b ∈ s

full_name: Filter.tendsto_atBot'
code: theorem tendsto_atBot' [Nonempty α] [SemilatticeInf α] {f : α → β} {l : Filter β} :
    Tendsto f atBot l ↔ ∀ s ∈ l, ∃ a, ∀ b ≤ a, f b ∈ s 
goal: Filter.Tendsto f Filter.atBot l ↔ ∀ s ∈ l, ∃ a, ∀ b ≤ a, f b ∈ s

full_name: Filter.tendsto_atTop_principal
code: theorem tendsto_atTop_principal [Nonempty β] [SemilatticeSup β] {f : β → α} {s : Set α} :
    Tendsto f atTop (𝓟 s) ↔ ∃ N, ∀ n ≥ N, f n ∈ s 
goal: Filter.Tendsto f Filter.atTop (𝓟 s) ↔ ∃ N, ∀ n ≥ N, f n ∈ s

full_name: Filter.tendsto_atBot_principal
code: theorem tendsto_atBot_principal [Nonempty β] [SemilatticeInf β] {f : β → α} {s : Set α} :
    Tendsto f atBot (𝓟 s) ↔ ∃ N, ∀ n ≤ N, f n ∈ s 
goal: Filter.Tendsto f Filter.atBot (𝓟 s) ↔ ∃ N, ∀ n ≤ N, f n ∈ s

full_name: Filter.tendsto_atTop_atTop
code: /-- A function `f` grows to `+∞` independent of an order-preserving embedding `e`. -/
theorem tendsto_atTop_atTop [Nonempty α] [SemilatticeSup α] [Preorder β] {f : α → β} :
    Tendsto f atTop atTop ↔ ∀ b : β, ∃ i : α, ∀ a : α, i ≤ a → b ≤ f a 
goal: Filter.Tendsto f Filter.atTop Filter.atTop ↔ ∀ (b : β), ∃ i, ∀ (a : α), i ≤ a → b ≤ f a

full_name: Filter.tendsto_atTop_atBot
code: theorem tendsto_atTop_atBot [Nonempty α] [SemilatticeSup α] [Preorder β] {f : α → β} :
    Tendsto f atTop atBot ↔ ∀ b : β, ∃ i : α, ∀ a : α, i ≤ a → f a ≤ b 
goal: Filter.Tendsto f Filter.atTop Filter.atBot ↔ ∀ (b : β), ∃ i, ∀ (a : α), i ≤ a → f a ≤ b

full_name: Filter.tendsto_atBot_atTop
code: theorem tendsto_atBot_atTop [Nonempty α] [SemilatticeInf α] [Preorder β] {f : α → β} :
    Tendsto f atBot atTop ↔ ∀ b : β, ∃ i : α, ∀ a : α, a ≤ i → b ≤ f a 
goal: Filter.Tendsto f Filter.atBot Filter.atTop ↔ ∀ (b : β), ∃ i, ∀ a ≤ i, b ≤ f a

full_name: Filter.tendsto_atBot_atBot
code: theorem tendsto_atBot_atBot [Nonempty α] [SemilatticeInf α] [Preorder β] {f : α → β} :
    Tendsto f atBot atBot ↔ ∀ b : β, ∃ i : α, ∀ a : α, a ≤ i → f a ≤ b 
goal: Filter.Tendsto f Filter.atBot Filter.atBot ↔ ∀ (b : β), ∃ i, ∀ a ≤ i, f a ≤ b

full_name: Filter.tendsto_atTop_atTop_of_monotone
code: theorem tendsto_atTop_atTop_of_monotone [Preorder α] [Preorder β] {f : α → β} (hf : Monotone f)
    (h : ∀ b, ∃ a, b ≤ f a) : Tendsto f atTop atTop 
goal: Filter.Tendsto f Filter.atTop Filter.atTop

full_name: Filter.tendsto_atTop_atBot_of_antitone
code: theorem tendsto_atTop_atBot_of_antitone [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f)
    (h : ∀ b, ∃ a, f a ≤ b) : Tendsto f atTop atBot 
goal: Filter.Tendsto f Filter.atTop Filter.atBot

full_name: Filter.tendsto_atBot_atBot_of_monotone
code: theorem tendsto_atBot_atBot_of_monotone [Preorder α] [Preorder β] {f : α → β} (hf : Monotone f)
    (h : ∀ b, ∃ a, f a ≤ b) : Tendsto f atBot atBot 
goal: Filter.Tendsto f Filter.atBot Filter.atBot

full_name: Filter.tendsto_atBot_atTop_of_antitone
code: theorem tendsto_atBot_atTop_of_antitone [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f)
    (h : ∀ b, ∃ a, b ≤ f a) : Tendsto f atBot atTop 
goal: Filter.Tendsto f Filter.atBot Filter.atTop

full_name: Filter.tendsto_atTop_atTop_iff_of_monotone
code: theorem tendsto_atTop_atTop_iff_of_monotone [Nonempty α] [SemilatticeSup α] [Preorder β] {f : α → β}
    (hf : Monotone f) : Tendsto f atTop atTop ↔ ∀ b : β, ∃ a : α, b ≤ f a 
goal: Filter.Tendsto f Filter.atTop Filter.atTop ↔ ∀ (b : β), ∃ a, b ≤ f a

full_name: Filter.tendsto_atTop_atBot_iff_of_antitone
code: theorem tendsto_atTop_atBot_iff_of_antitone [Nonempty α] [SemilatticeSup α] [Preorder β] {f : α → β}
    (hf : Antitone f) : Tendsto f atTop atBot ↔ ∀ b : β, ∃ a : α, f a ≤ b 
goal: Filter.Tendsto f Filter.atTop Filter.atBot ↔ ∀ (b : β), ∃ a, f a ≤ b

full_name: Filter.tendsto_atBot_atBot_iff_of_monotone
code: theorem tendsto_atBot_atBot_iff_of_monotone [Nonempty α] [SemilatticeInf α] [Preorder β] {f : α → β}
    (hf : Monotone f) : Tendsto f atBot atBot ↔ ∀ b : β, ∃ a : α, f a ≤ b 
goal: Filter.Tendsto f Filter.atBot Filter.atBot ↔ ∀ (b : β), ∃ a, f a ≤ b

full_name: Filter.tendsto_atBot_atTop_iff_of_antitone
code: theorem tendsto_atBot_atTop_iff_of_antitone [Nonempty α] [SemilatticeInf α] [Preorder β] {f : α → β}
    (hf : Antitone f) : Tendsto f atBot atTop ↔ ∀ b : β, ∃ a : α, b ≤ f a 
goal: Filter.Tendsto f Filter.atBot Filter.atTop ↔ ∀ (b : β), ∃ a, b ≤ f a

full_name: Filter.comap_embedding_atTop
code: theorem comap_embedding_atTop [Preorder β] [Preorder γ] {e : β → γ}
    (hm : ∀ b₁ b₂, e b₁ ≤ e b₂ ↔ b₁ ≤ b₂) (hu : ∀ c, ∃ b, c ≤ e b) : comap e atTop = atTop 
goal: Filter.comap e Filter.atTop = Filter.atTop

full_name: Filter.comap_embedding_atBot
code: theorem comap_embedding_atBot [Preorder β] [Preorder γ] {e : β → γ}
    (hm : ∀ b₁ b₂, e b₁ ≤ e b₂ ↔ b₁ ≤ b₂) (hu : ∀ c, ∃ b, e b ≤ c) : comap e atBot = atBot 
goal: Filter.comap e Filter.atBot = Filter.atBot

full_name: Filter.tendsto_atTop_embedding
code: theorem tendsto_atTop_embedding [Preorder β] [Preorder γ] {f : α → β} {e : β → γ} {l : Filter α}
    (hm : ∀ b₁ b₂, e b₁ ≤ e b₂ ↔ b₁ ≤ b₂) (hu : ∀ c, ∃ b, c ≤ e b) :
    Tendsto (e ∘ f) l atTop ↔ Tendsto f l atTop 
goal: Filter.Tendsto (e ∘ f) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop

full_name: Filter.tendsto_atBot_embedding
code: /-- A function `f` goes to `-∞` independent of an order-preserving embedding `e`. -/
theorem tendsto_atBot_embedding [Preorder β] [Preorder γ] {f : α → β} {e : β → γ} {l : Filter α}
    (hm : ∀ b₁ b₂, e b₁ ≤ e b₂ ↔ b₁ ≤ b₂) (hu : ∀ c, ∃ b, e b ≤ c) :
    Tendsto (e ∘ f) l atBot ↔ Tendsto f l atBot 
goal: Filter.Tendsto (e ∘ f) l Filter.atBot ↔ Filter.Tendsto f l Filter.atBot

full_name: Filter.tendsto_finset_range
code: theorem tendsto_finset_range : Tendsto Finset.range atTop atTop 
goal: Filter.Tendsto Finset.range Filter.atTop Filter.atTop

full_name: Filter.atTop_finset_eq_iInf
code: theorem atTop_finset_eq_iInf : (atTop : Filter (Finset α)) = ⨅ x : α, 𝓟 (Ici {x}) 
goal: Filter.atTop = ⨅ x, 𝓟 (Set.Ici {x})

full_name: Filter.tendsto_atTop_finset_of_monotone
code: /-- If `f` is a monotone sequence of `Finset`s and each `x` belongs to one of `f n`, then
`Tendsto f atTop atTop`. -/
theorem tendsto_atTop_finset_of_monotone [Preorder β] {f : β → Finset α} (h : Monotone f)
    (h' : ∀ x : α, ∃ n, x ∈ f n) : Tendsto f atTop atTop 
goal: Filter.Tendsto f Filter.atTop Filter.atTop

full_name: Filter.tendsto_finset_image_atTop_atTop
code: theorem tendsto_finset_image_atTop_atTop [DecidableEq β] {i : β → γ} {j : γ → β}
    (h : Function.LeftInverse j i) : Tendsto (Finset.image j) atTop atTop 
goal: Filter.Tendsto (Finset.image j) Filter.atTop Filter.atTop

full_name: Filter.tendsto_finset_preimage_atTop_atTop
code: theorem tendsto_finset_preimage_atTop_atTop {f : α → β} (hf : Function.Injective f) :
    Tendsto (fun s : Finset β => s.preimage f (hf.injOn)) atTop atTop 
goal: Filter.Tendsto (fun s => s.preimage f ⋯) Filter.atTop Filter.atTop

full_name: Filter.prod_atTop_atTop_eq
code: theorem prod_atTop_atTop_eq [Preorder α] [Preorder β] :
    (atTop : Filter α) ×ˢ (atTop : Filter β) = (atTop : Filter (α × β)) 
goal: Filter.atTop ×ˢ Filter.atTop = Filter.atTop

full_name: Filter.prod_atBot_atBot_eq
code: theorem prod_atBot_atBot_eq [Preorder α] [Preorder β] :
    (atBot : Filter α) ×ˢ (atBot : Filter β) = (atBot : Filter (α × β)) 
goal: Filter.atBot ×ˢ Filter.atBot = Filter.atBot

full_name: Filter.prod_map_atTop_eq
code: theorem prod_map_atTop_eq {α₁ α₂ β₁ β₂ : Type*} [Preorder β₁] [Preorder β₂]
    (u₁ : β₁ → α₁) (u₂ : β₂ → α₂) : map u₁ atTop ×ˢ map u₂ atTop = map (Prod.map u₁ u₂) atTop 
goal: Filter.map u₁ Filter.atTop ×ˢ Filter.map u₂ Filter.atTop = Filter.map (Prod.map u₁ u₂) Filter.atTop

full_name: Filter.prod_map_atBot_eq
code: theorem prod_map_atBot_eq {α₁ α₂ β₁ β₂ : Type*} [Preorder β₁] [Preorder β₂]
    (u₁ : β₁ → α₁) (u₂ : β₂ → α₂) : map u₁ atBot ×ˢ map u₂ atBot = map (Prod.map u₁ u₂) atBot 
goal: Filter.map u₁ Filter.atBot ×ˢ Filter.map u₂ Filter.atBot = Filter.map (Prod.map u₁ u₂) Filter.atBot

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

full_name: Filter.tendsto_atBot_diagonal
code: theorem tendsto_atBot_diagonal [SemilatticeInf α] : Tendsto (fun a : α => (a, a)) atBot atBot 
goal: Filter.Tendsto (fun a => (a, a)) Filter.atBot Filter.atBot

full_name: Filter.tendsto_atTop_diagonal
code: theorem tendsto_atTop_diagonal [SemilatticeSup α] : Tendsto (fun a : α => (a, a)) atTop atTop 
goal: Filter.Tendsto (fun a => (a, a)) Filter.atTop Filter.atTop

full_name: Filter.Tendsto.prod_map_prod_atBot
code: theorem Tendsto.prod_map_prod_atBot [SemilatticeInf γ] {F : Filter α} {G : Filter β} {f : α → γ}
    {g : β → γ} (hf : Tendsto f F atBot) (hg : Tendsto g G atBot) :
    Tendsto (Prod.map f g) (F ×ˢ G) atBot 
goal: Filter.Tendsto (Prod.map f g) (F ×ˢ G) Filter.atBot

full_name: Filter.Tendsto.prod_map_prod_atTop
code: theorem Tendsto.prod_map_prod_atTop [SemilatticeSup γ] {F : Filter α} {G : Filter β} {f : α → γ}
    {g : β → γ} (hf : Tendsto f F atTop) (hg : Tendsto g G atTop) :
    Tendsto (Prod.map f g) (F ×ˢ G) atTop 
goal: Filter.Tendsto (Prod.map f g) (F ×ˢ G) Filter.atTop

full_name: Filter.Tendsto.prod_atBot
code: theorem Tendsto.prod_atBot [SemilatticeInf α] [SemilatticeInf γ] {f g : α → γ}
    (hf : Tendsto f atBot atBot) (hg : Tendsto g atBot atBot) :
    Tendsto (Prod.map f g) atBot atBot 
goal: Filter.Tendsto (Prod.map f g) Filter.atBot Filter.atBot

full_name: Filter.Tendsto.prod_atTop
code: theorem Tendsto.prod_atTop [SemilatticeSup α] [SemilatticeSup γ] {f g : α → γ}
    (hf : Tendsto f atTop atTop) (hg : Tendsto g atTop atTop) :
    Tendsto (Prod.map f g) atTop atTop 
goal: Filter.Tendsto (Prod.map f g) Filter.atTop Filter.atTop

full_name: Filter.eventually_atBot_prod_self
code: theorem eventually_atBot_prod_self [SemilatticeInf α] [Nonempty α] {p : α × α → Prop} :
    (∀ᶠ x in atBot, p x) ↔ ∃ a, ∀ k l, k ≤ a → l ≤ a → p (k, l) 
goal: (∀ᶠ (x : α × α) in Filter.atBot, p x) ↔ ∃ a, ∀ (k l : α), k ≤ a → l ≤ a → p (k, l)

full_name: Filter.eventually_atTop_prod_self
code: theorem eventually_atTop_prod_self [SemilatticeSup α] [Nonempty α] {p : α × α → Prop} :
    (∀ᶠ x in atTop, p x) ↔ ∃ a, ∀ k l, a ≤ k → a ≤ l → p (k, l) 
goal: (∀ᶠ (x : α × α) in Filter.atTop, p x) ↔ ∃ a, ∀ (k l : α), a ≤ k → a ≤ l → p (k, l)

full_name: Filter.eventually_atBot_prod_self'
code: theorem eventually_atBot_prod_self' [SemilatticeInf α] [Nonempty α] {p : α × α → Prop} :
    (∀ᶠ x in atBot, p x) ↔ ∃ a, ∀ k ≤ a, ∀ l ≤ a, p (k, l) 
goal: (∀ᶠ (x : α × α) in Filter.atBot, p x) ↔ ∃ a, ∀ k ≤ a, ∀ l ≤ a, p (k, l)

full_name: Filter.eventually_atTop_prod_self'
code: theorem eventually_atTop_prod_self' [SemilatticeSup α] [Nonempty α] {p : α × α → Prop} :
    (∀ᶠ x in atTop, p x) ↔ ∃ a, ∀ k ≥ a, ∀ l ≥ a, p (k, l) 
goal: (∀ᶠ (x : α × α) in Filter.atTop, p x) ↔ ∃ a, ∀ k ≥ a, ∀ l ≥ a, p (k, l)

full_name: Filter.eventually_atTop_curry
code: theorem eventually_atTop_curry [SemilatticeSup α] [SemilatticeSup β] {p : α × β → Prop}
    (hp : ∀ᶠ x : α × β in Filter.atTop, p x) : ∀ᶠ k in atTop, ∀ᶠ l in atTop, p (k, l) 
goal: ∀ᶠ (k : α) in Filter.atTop, ∀ᶠ (l : β) in Filter.atTop, p (k, l)

full_name: Filter.eventually_atBot_curry
code: theorem eventually_atBot_curry [SemilatticeInf α] [SemilatticeInf β] {p : α × β → Prop}
    (hp : ∀ᶠ x : α × β in Filter.atBot, p x) : ∀ᶠ k in atBot, ∀ᶠ l in atBot, p (k, l) 
goal: ∀ᶠ (k : α) in Filter.atBot, ∀ᶠ (l : β) in Filter.atBot, p (k, l)

full_name: Filter.map_atTop_eq_of_gc
code: /-- 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 map_atTop_eq_of_gc [SemilatticeSup α] [SemilatticeSup β] {f : α → β} (g : β → α) (b' : β)
    (hf : Monotone f) (gc : ∀ a, ∀ b ≥ b', f a ≤ b ↔ a ≤ g b) (hgi : ∀ b ≥ b', b ≤ f (g b)) :
    map f atTop = atTop 
goal: Filter.map f Filter.atTop = Filter.atTop

full_name: Filter.map_atBot_eq_of_gc
code: theorem map_atBot_eq_of_gc [SemilatticeInf α] [SemilatticeInf β] {f : α → β} (g : β → α) (b' : β)
    (hf : Monotone f) (gc : ∀ a, ∀ b ≤ b', b ≤ f a ↔ g b ≤ a) (hgi : ∀ b ≤ b', f (g b) ≤ b) :
    map f atBot = atBot 
goal: Filter.map f Filter.atBot = Filter.atBot

full_name: Filter.map_val_atTop_of_Ici_subset
code: theorem map_val_atTop_of_Ici_subset [SemilatticeSup α] {a : α} {s : Set α} (h : Ici a ⊆ s) :
    map ((↑) : s → α) atTop = atTop 
goal: Filter.map Subtype.val Filter.atTop = Filter.atTop

full_name: Filter.map_val_Ici_atTop
code: /-- The image of the filter `atTop` on `Ici a` under the coercion equals `atTop`. -/
@[simp]
theorem map_val_Ici_atTop [SemilatticeSup α] (a : α) : map ((↑) : Ici a → α) atTop = atTop 
goal: Filter.map Subtype.val Filter.atTop = Filter.atTop

full_name: Filter.map_val_Ioi_atTop
code: /-- The image of the filter `atTop` on `Ioi a` under the coercion equals `atTop`. -/
@[simp]
theorem map_val_Ioi_atTop [SemilatticeSup α] [NoMaxOrder α] (a : α) :
    map ((↑) : Ioi a → α) atTop = atTop 
goal: Filter.map Subtype.val Filter.atTop = Filter.atTop

full_name: Filter.atTop_Ioi_eq
code: /-- The `atTop` filter for an open interval `Ioi a` comes from the `atTop` filter in the ambient
order. -/
theorem atTop_Ioi_eq [SemilatticeSup α] (a : α) : atTop = comap ((↑) : Ioi a → α) atTop 
goal: Filter.atTop = Filter.comap Subtype.val Filter.atTop

full_name: Filter.atTop_Ici_eq
code: /-- The `atTop` filter for an open interval `Ici a` comes from the `atTop` filter in the ambient
order. -/
theorem atTop_Ici_eq [SemilatticeSup α] (a : α) : atTop = comap ((↑) : Ici a → α) atTop 
goal: Filter.atTop = Filter.comap Subtype.val Filter.atTop

full_name: Filter.map_val_Iio_atBot
code: /-- The `atBot` filter for an open interval `Iio a` comes from the `atBot` filter in the ambient
order. -/
@[simp]
theorem map_val_Iio_atBot [SemilatticeInf α] [NoMinOrder α] (a : α) :
    map ((↑) : Iio a → α) atBot = atBot 
goal: Filter.map Subtype.val Filter.atBot = Filter.atBot

full_name: Filter.atBot_Iio_eq
code: /-- The `atBot` filter for an open interval `Iio a` comes from the `atBot` filter in the ambient
order. -/
theorem atBot_Iio_eq [SemilatticeInf α] (a : α) : atBot = comap ((↑) : Iio a → α) atBot 
goal: Filter.atBot = Filter.comap Subtype.val Filter.atBot

full_name: Filter.map_val_Iic_atBot
code: /-- The `atBot` filter for an open interval `Iic a` comes from the `atBot` filter in the ambient
order. -/
@[simp]
theorem map_val_Iic_atBot [SemilatticeInf α] (a : α) : map ((↑) : Iic a → α) atBot = atBot 
goal: Filter.map Subtype.val Filter.atBot = Filter.atBot

full_name: Filter.atBot_Iic_eq
code: /-- The `atBot` filter for an open interval `Iic a` comes from the `atBot` filter in the ambient
order. -/
theorem atBot_Iic_eq [SemilatticeInf α] (a : α) : atBot = comap ((↑) : Iic a → α) atBot 
goal: Filter.atBot = Filter.comap Subtype.val Filter.atBot

full_name: Filter.tendsto_Ioi_atTop
code: theorem tendsto_Ioi_atTop [SemilatticeSup α] {a : α} {f : β → Ioi a} {l : Filter β} :
    Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l atTop 
goal: Filter.Tendsto f l Filter.atTop ↔ Filter.Tendsto (fun x => ↑(f x)) l Filter.atTop

full_name: Filter.tendsto_Iio_atBot
code: theorem tendsto_Iio_atBot [SemilatticeInf α] {a : α} {f : β → Iio a} {l : Filter β} :
    Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l atBot 
goal: Filter.Tendsto f l Filter.atBot ↔ Filter.Tendsto (fun x => ↑(f x)) l Filter.atBot

full_name: Filter.tendsto_Ici_atTop
code: theorem tendsto_Ici_atTop [SemilatticeSup α] {a : α} {f : β → Ici a} {l : Filter β} :
    Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l atTop 
goal: Filter.Tendsto f l Filter.atTop ↔ Filter.Tendsto (fun x => ↑(f x)) l Filter.atTop

full_name: Filter.tendsto_Iic_atBot
code: theorem tendsto_Iic_atBot [SemilatticeInf α] {a : α} {f : β → Iic a} {l : Filter β} :
    Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l atBot 
goal: Filter.Tendsto f l Filter.atBot ↔ Filter.Tendsto (fun x => ↑(f x)) l Filter.atBot

full_name: Filter.tendsto_comp_val_Ioi_atTop
code: @[simp, nolint simpNF] -- Porting note: linter claims that LHS doesn't simplify. It does.
theorem tendsto_comp_val_Ioi_atTop [SemilatticeSup α] [NoMaxOrder α] {a : α} {f : α → β}
    {l : Filter β} : Tendsto (fun x : Ioi a => f x) atTop l ↔ Tendsto f atTop l 
goal: Filter.Tendsto (fun x => f ↑x) Filter.atTop l ↔ Filter.Tendsto f Filter.atTop l

full_name: Filter.tendsto_comp_val_Ici_atTop
code: @[simp, nolint simpNF] -- Porting note: linter claims that LHS doesn't simplify. It does.
theorem tendsto_comp_val_Ici_atTop [SemilatticeSup α] {a : α} {f : α → β} {l : Filter β} :
    Tendsto (fun x : Ici a => f x) atTop l ↔ Tendsto f atTop l 
goal: Filter.Tendsto (fun x => f ↑x) Filter.atTop l ↔ Filter.Tendsto f Filter.atTop l

full_name: Filter.tendsto_comp_val_Iio_atBot
code: @[simp, nolint simpNF] -- Porting note: linter claims that LHS doesn't simplify. It does.
theorem tendsto_comp_val_Iio_atBot [SemilatticeInf α] [NoMinOrder α] {a : α} {f : α → β}
    {l : Filter β} : Tendsto (fun x : Iio a => f x) atBot l ↔ Tendsto f atBot l 
goal: Filter.Tendsto (fun x => f ↑x) Filter.atBot l ↔ Filter.Tendsto f Filter.atBot l

full_name: Filter.tendsto_comp_val_Iic_atBot
code: @[simp, nolint simpNF] -- Porting note: linter claims that LHS doesn't simplify. It does.
theorem tendsto_comp_val_Iic_atBot [SemilatticeInf α] {a : α} {f : α → β} {l : Filter β} :
    Tendsto (fun x : Iic a => f x) atBot l ↔ Tendsto f atBot l 
goal: Filter.Tendsto (fun x => f ↑x) Filter.atBot l ↔ Filter.Tendsto f Filter.atBot l

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

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

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

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

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

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

full_name: Filter.tendsto_atTop_atTop_of_monotone'
code: /-- If `u` is a monotone function with linear ordered codomain and the range of `u` is not bounded
above, then `Tendsto u atTop atTop`. -/
theorem tendsto_atTop_atTop_of_monotone' [Preorder ι] [LinearOrder α] {u : ι → α} (h : Monotone u)
    (H : ¬BddAbove (range u)) : Tendsto u atTop atTop 
goal: Filter.Tendsto u Filter.atTop Filter.atTop

full_name: Filter.tendsto_atBot_atBot_of_monotone'
code: /-- If `u` is a monotone function with linear ordered codomain and the range of `u` is not bounded
below, then `Tendsto u atBot atBot`. -/
theorem tendsto_atBot_atBot_of_monotone' [Preorder ι] [LinearOrder α] {u : ι → α} (h : Monotone u)
    (H : ¬BddBelow (range u)) : Tendsto u atBot atBot 
goal: Filter.Tendsto u Filter.atBot Filter.atBot

full_name: Filter.unbounded_of_tendsto_atTop
code: theorem unbounded_of_tendsto_atTop [Nonempty α] [SemilatticeSup α] [Preorder β] [NoMaxOrder β]
    {f : α → β} (h : Tendsto f atTop atTop) : ¬BddAbove (range f) 
goal: ¬BddAbove (Set.range f)

full_name: Filter.unbounded_of_tendsto_atBot
code: theorem unbounded_of_tendsto_atBot [Nonempty α] [SemilatticeSup α] [Preorder β] [NoMinOrder β]
    {f : α → β} (h : Tendsto f atTop atBot) : ¬BddBelow (range f) 
goal: ¬BddBelow (Set.range f)

full_name: Filter.unbounded_of_tendsto_atTop'
code: theorem unbounded_of_tendsto_atTop' [Nonempty α] [SemilatticeInf α] [Preorder β] [NoMaxOrder β]
    {f : α → β} (h : Tendsto f atBot atTop) : ¬BddAbove (range f) 
goal: ¬BddAbove (Set.range f)

full_name: Filter.unbounded_of_tendsto_atBot'
code: theorem unbounded_of_tendsto_atBot' [Nonempty α] [SemilatticeInf α] [Preorder β] [NoMinOrder β]
    {f : α → β} (h : Tendsto f atBot atBot) : ¬BddBelow (range f) 
goal: ¬BddBelow (Set.range f)

full_name: Filter.tendsto_atTop_of_monotone_of_filter
code: /-- If a monotone function `u : ι → α` tends to `atTop` along *some* non-trivial filter `l`, then
it tends to `atTop` along `atTop`. -/
theorem tendsto_atTop_of_monotone_of_filter [Preorder ι] [Preorder α] {l : Filter ι} {u : ι → α}
    (h : Monotone u) [NeBot l] (hu : Tendsto u l atTop) : Tendsto u atTop atTop 
goal: Filter.Tendsto u Filter.atTop Filter.atTop

full_name: Filter.tendsto_atBot_of_monotone_of_filter
code: /-- If a monotone function `u : ι → α` tends to `atBot` along *some* non-trivial filter `l`, then
it tends to `atBot` along `atBot`. -/
theorem tendsto_atBot_of_monotone_of_filter [Preorder ι] [Preorder α] {l : Filter ι} {u : ι → α}
    (h : Monotone u) [NeBot l] (hu : Tendsto u l atBot) : Tendsto u atBot atBot 
goal: Filter.Tendsto u Filter.atBot Filter.atBot

full_name: Filter.tendsto_atTop_of_monotone_of_subseq
code: theorem tendsto_atTop_of_monotone_of_subseq [Preorder ι] [Preorder α] {u : ι → α} {φ : ι' → ι}
    (h : Monotone u) {l : Filter ι'} [NeBot l] (H : Tendsto (u ∘ φ) l atTop) :
    Tendsto u atTop atTop 
goal: Filter.Tendsto u Filter.atTop Filter.atTop

full_name: Filter.tendsto_atBot_of_monotone_of_subseq
code: theorem tendsto_atBot_of_monotone_of_subseq [Preorder ι] [Preorder α] {u : ι → α} {φ : ι' → ι}
    (h : Monotone u) {l : Filter ι'} [NeBot l] (H : Tendsto (u ∘ φ) l atBot) :
    Tendsto u atBot atBot 
goal: Filter.Tendsto u Filter.atBot Filter.atBot

full_name: Filter.map_atTop_finset_prod_le_of_prod_eq
code: /-- Let `f` and `g` be two maps to the same commutative monoid. This lemma gives a sufficient
condition for comparison of the filter `atTop.map (fun s ↦ ∏ b ∈ s, f b)` with
`atTop.map (fun s ↦ ∏ b ∈ s, g b)`. This is useful to compare the set of limit points of
`Π b in s, f b` as `s → atTop` with the similar set for `g`. -/
@[to_additive "Let `f` and `g` be two maps to the same commutative additive monoid. This lemma gives
a sufficient condition for comparison of the filter `atTop.map (fun s ↦ ∑ b ∈ s, f b)` with
`atTop.map (fun s ↦ ∑ b ∈ s, g b)`. This is useful to compare the set of limit points of
`∑ b ∈ s, f b` as `s → atTop` with the similar set for `g`."]
theorem map_atTop_finset_prod_le_of_prod_eq [CommMonoid α] {f : β → α} {g : γ → α}
    (h_eq : ∀ u : Finset γ,
      ∃ v : Finset β, ∀ v', v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x ∈ u', g x = ∏ b ∈ v', f b) :
    (atTop.map fun s : Finset β => ∏ b ∈ s, f b) ≤
      atTop.map fun s : Finset γ => ∏ x ∈ s, g x 
goal: Filter.map (fun s => ∏ b ∈ s, f b) Filter.atTop ≤ Filter.map (fun s => ∏ x ∈ s, g x) Filter.atTop

full_name: Filter.map_atTop_finset_sum_le_of_sum_eq
code: /-- Let `f` and `g` be two maps to the same commutative monoid. This lemma gives a sufficient
condition for comparison of the filter `atTop.map (fun s ↦ ∏ b ∈ s, f b)` with
`atTop.map (fun s ↦ ∏ b ∈ s, g b)`. This is useful to compare the set of limit points of
`Π b in s, f b` as `s → atTop` with the similar set for `g`. -/
@[to_additive "Let `f` and `g` be two maps to the same commutative additive monoid. This lemma gives
a sufficient condition for comparison of the filter `atTop.map (fun s ↦ ∑ b ∈ s, f b)` with
`atTop.map (fun s ↦ ∑ b ∈ s, g b)`. This is useful to compare the set of limit points of
`∑ b ∈ s, f b` as `s → atTop` with the similar set for `g`."]
theorem map_atTop_finset_prod_le_of_prod_eq [CommMonoid α] {f : β → α} {g : γ → α}
    (h_eq : ∀ u : Finset γ,
      ∃ v : Finset β, ∀ v', v ⊆ v' → ∃ u', u ⊆ u' ∧ ∏ x ∈ u', g x = ∏ b ∈ v', f b) :
    (atTop.map fun s : Finset β => ∏ b ∈ s, f b) ≤
      atTop.map fun s : Finset γ => ∏ x ∈ s, g x 
goal: Filter.map (fun s => ∑ b ∈ s, f b) Filter.atTop ≤ Filter.map (fun s => ∑ x ∈ s, g x) Filter.atTop

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

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

full_name: Filter.HasAntitoneBasis.comp_mono
code: theorem HasAntitoneBasis.comp_mono [SemilatticeSup ι] [Nonempty ι] [Preorder ι'] {l : Filter α}
    {s : ι' → Set α} (hs : l.HasAntitoneBasis s) {φ : ι → ι'} (φ_mono : Monotone φ)
    (hφ : Tendsto φ atTop atTop) : l.HasAntitoneBasis (s ∘ φ) 
goal: l.HasAntitoneBasis (s ∘ φ)

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

full_name: Filter.HasAntitoneBasis.subbasis_with_rel
code: /-- Given an antitone basis `s : ℕ → Set α` of a filter, extract an antitone subbasis `s ∘ φ`,
`φ : ℕ → ℕ`, such that `m < n` implies `r (φ m) (φ n)`. This lemma can be used to extract an
antitone basis with basis sets decreasing "sufficiently fast". -/
theorem HasAntitoneBasis.subbasis_with_rel {f : Filter α} {s : ℕ → Set α}
    (hs : f.HasAntitoneBasis s) {r : ℕ → ℕ → Prop} (hr : ∀ m, ∀ᶠ n in atTop, r m n) :
    ∃ φ : ℕ → ℕ, StrictMono φ ∧ (∀ ⦃m n⦄, m < n → r (φ m) (φ n)) ∧ f.HasAntitoneBasis (s ∘ φ) 
goal: ∃ φ, StrictMono φ ∧ (∀ ⦃m n : ℕ⦄, m < n → r (φ m) (φ n)) ∧ f.HasAntitoneBasis (s ∘ φ)

full_name: Filter.exists_seq_tendsto
code: /-- If `f` is a nontrivial countably generated filter, then there exists a sequence that converges
to `f`. -/
theorem exists_seq_tendsto (f : Filter α) [IsCountablyGenerated f] [NeBot f] :
    ∃ x : ℕ → α, Tendsto x atTop f 
goal: ∃ x, Filter.Tendsto x Filter.atTop f

full_name: Filter.exists_seq_monotone_tendsto_atTop_atTop
code: theorem exists_seq_monotone_tendsto_atTop_atTop (α : Type*) [SemilatticeSup α] [Nonempty α]
    [(atTop : Filter α).IsCountablyGenerated] :
    ∃ xs : ℕ → α, Monotone xs ∧ Tendsto xs atTop atTop 
goal: ∃ xs, Monotone xs ∧ Filter.Tendsto xs Filter.atTop Filter.atTop

full_name: Filter.exists_seq_antitone_tendsto_atTop_atBot
code: theorem exists_seq_antitone_tendsto_atTop_atBot (α : Type*) [SemilatticeInf α] [Nonempty α]
    [h2 : (atBot : Filter α).IsCountablyGenerated] :
    ∃ xs : ℕ → α, Antitone xs ∧ Tendsto xs atTop atBot 
goal: ∃ xs, Antitone xs ∧ Filter.Tendsto xs Filter.atTop Filter.atBot

full_name: Filter.tendsto_iff_seq_tendsto
code: /-- 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 tendsto_iff_seq_tendsto {f : α → β} {k : Filter α} {l : Filter β} [k.IsCountablyGenerated] :
    Tendsto f k l ↔ ∀ x : ℕ → α, Tendsto x atTop k → Tendsto (f ∘ x) atTop l 
goal: Filter.Tendsto f k l ↔ ∀ (x : ℕ → α), Filter.Tendsto x Filter.atTop k → Filter.Tendsto (f ∘ x) Filter.atTop l

full_name: Filter.tendsto_of_seq_tendsto
code: theorem tendsto_of_seq_tendsto {f : α → β} {k : Filter α} {l : Filter β} [k.IsCountablyGenerated] :
    (∀ x : ℕ → α, Tendsto x atTop k → Tendsto (f ∘ x) atTop l) → Tendsto f k l 
goal: (∀ (x : ℕ → α), Filter.Tendsto x Filter.atTop k → Filter.Tendsto (f ∘ x) Filter.atTop l) → Filter.Tendsto f k l

full_name: Filter.eventually_iff_seq_eventually
code: theorem eventually_iff_seq_eventually {ι : Type*} {l : Filter ι} {p : ι → Prop}
    [l.IsCountablyGenerated] :
    (∀ᶠ n in l, p n) ↔ ∀ x : ℕ → ι, Tendsto x atTop l → ∀ᶠ n : ℕ in atTop, p (x n) 
goal: (∀ᶠ (n : ι) in l, p n) ↔ ∀ (x : ℕ → ι), Filter.Tendsto x Filter.atTop l → ∀ᶠ (n : ℕ) in Filter.atTop, p (x n)

full_name: Filter.frequently_iff_seq_frequently
code: theorem frequently_iff_seq_frequently {ι : Type*} {l : Filter ι} {p : ι → Prop}
    [l.IsCountablyGenerated] :
    (∃ᶠ n in l, p n) ↔ ∃ x : ℕ → ι, Tendsto x atTop l ∧ ∃ᶠ n : ℕ in atTop, p (x n) 
goal: (∃ᶠ (n : ι) in l, p n) ↔ ∃ x, Filter.Tendsto x Filter.atTop l ∧ ∃ᶠ (n : ℕ) in Filter.atTop, p (x n)

full_name: Filter.subseq_forall_of_frequently
code: theorem subseq_forall_of_frequently {ι : Type*} {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)) 
goal: ∃ ns, Filter.Tendsto (fun n => x (ns n)) Filter.atTop l ∧ ∀ (n : ℕ), p (x (ns n))

full_name: Filter.exists_seq_forall_of_frequently
code: theorem exists_seq_forall_of_frequently {ι : Type*} {l : Filter ι} {p : ι → Prop}
    [l.IsCountablyGenerated] (h : ∃ᶠ n in l, p n) :
    ∃ ns : ℕ → ι, Tendsto ns atTop l ∧ ∀ n, p (ns n) 
goal: ∃ ns, Filter.Tendsto ns Filter.atTop l ∧ ∀ (n : ℕ), p (ns n)

full_name: Filter.frequently_iff_seq_forall
code: lemma frequently_iff_seq_forall {ι : Type*} {l : Filter ι} {p : ι → Prop}
    [l.IsCountablyGenerated] :
    (∃ᶠ n in l, p n) ↔ ∃ ns : ℕ → ι, Tendsto ns atTop l ∧ ∀ n, p (ns n) 
goal: (∃ᶠ (n : ι) in l, p n) ↔ ∃ ns, Filter.Tendsto ns Filter.atTop l ∧ ∀ (n : ℕ), p (ns n)

full_name: Filter.tendsto_of_subseq_tendsto
code: /-- A sequence converges if every subsequence has a convergent subsequence. -/
theorem tendsto_of_subseq_tendsto {ι : Type*} {x : ι → α} {f : Filter α} {l : Filter ι}
    [l.IsCountablyGenerated]
    (hxy : ∀ ns : ℕ → ι, Tendsto ns atTop l →
      ∃ ms : ℕ → ℕ, Tendsto (fun n => x (ns <| ms n)) atTop f) :
    Tendsto x l f 
goal: Filter.Tendsto x l f

full_name: Filter.subseq_tendsto_of_neBot
code: theorem subseq_tendsto_of_neBot {f : Filter α} [IsCountablyGenerated f] {u : ℕ → α}
    (hx : NeBot (f ⊓ map u atTop)) : ∃ θ : ℕ → ℕ, StrictMono θ ∧ Tendsto (u ∘ θ) atTop f 
goal: ∃ θ, StrictMono θ ∧ Filter.Tendsto (u ∘ θ) Filter.atTop f

full_name: exists_lt_mul_self
code: theorem exists_lt_mul_self (a : R) : ∃ x ≥ 0, a < x * x 
goal: ∃ x ≥ 0, a < x * x

full_name: exists_le_mul_self
code: theorem exists_le_mul_self (a : R) : ∃ x ≥ 0, a ≤ x * x 
goal: ∃ x ≥ 0, a ≤ x * x

full_name: Monotone.piecewise_eventually_eq_iUnion
code: theorem Monotone.piecewise_eventually_eq_iUnion {β : α → Type*} [Preorder ι] {s : ι → Set α}
    [∀ i, DecidablePred (· ∈ s i)] [DecidablePred (· ∈ ⋃ i, s i)]
    (hs : Monotone s) (f g : (a : α) → β a) (a : α) :
    ∀ᶠ i in atTop, (s i).piecewise f g a = (⋃ i, s i).piecewise f g a 
goal: ∀ᶠ (i : ι) in Filter.atTop, (s i).piecewise f g a = (⋃ i, s i).piecewise f g a

full_name: Antitone.piecewise_eventually_eq_iInter
code: theorem Antitone.piecewise_eventually_eq_iInter {β : α → Type*} [Preorder ι] {s : ι → Set α}
    [∀ i, DecidablePred (· ∈ s i)] [DecidablePred (· ∈ ⋂ i, s i)]
    (hs : Antitone s) (f g : (a : α) → β a) (a : α) :
    ∀ᶠ i in atTop, (s i).piecewise f g a = (⋂ i, s i).piecewise f g a 
goal: ∀ᶠ (i : ι) in Filter.atTop, (s i).piecewise f g a = (⋂ i, s i).piecewise f g a

full_name: Function.Injective.map_atTop_finset_sum_eq
code: /-- 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
`atTop.map (fun s ↦ ∏ i ∈ s, f (g i))` and `atTop.map (fun s ↦ ∏ i ∈ 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. -/
@[to_additive]
theorem Function.Injective.map_atTop_finset_prod_eq [CommMonoid α] {g : γ → β}
    (hg : Function.Injective g) {f : β → α} (hf : ∀ x, x ∉ Set.range g → f x = 1) :
    map (fun s => ∏ i ∈ s, f (g i)) atTop = map (fun s => ∏ i ∈ s, f i) atTop 
goal: Filter.map (fun s => ∑ i ∈ s, f (g i)) Filter.atTop = Filter.map (fun s => ∑ i ∈ s, f i) Filter.atTop

full_name: Function.Injective.map_atTop_finset_prod_eq
code: /-- 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
`atTop.map (fun s ↦ ∏ i ∈ s, f (g i))` and `atTop.map (fun s ↦ ∏ i ∈ 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. -/
@[to_additive]
theorem Function.Injective.map_atTop_finset_prod_eq [CommMonoid α] {g : γ → β}
    (hg : Function.Injective g) {f : β → α} (hf : ∀ x, x ∉ Set.range g → f x = 1) :
    map (fun s => ∏ i ∈ s, f (g i)) atTop = map (fun s => ∏ i ∈ s, f i) atTop 
goal: Filter.map (fun s => ∏ i ∈ s, f (g i)) Filter.atTop = Filter.map (fun s => ∏ i ∈ s, f i) Filter.atTop