File: Mathlib/Order/Filter/Archimedean.lean

full_name: Nat.comap_cast_atTop
code: @[simp]
theorem Nat.comap_cast_atTop [StrictOrderedSemiring R] [Archimedean R] :
    comap ((↑) : ℕ → R) atTop = atTop 
goal: Filter.comap Nat.cast Filter.atTop = Filter.atTop

full_name: tendsto_natCast_atTop_iff
code: theorem tendsto_natCast_atTop_iff [StrictOrderedSemiring R] [Archimedean R] {f : α → ℕ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atTop ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun n => ↑(f n)) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop

full_name: tendsto_natCast_atTop_atTop
code: theorem tendsto_natCast_atTop_atTop [OrderedSemiring R] [Archimedean R] :
    Tendsto ((↑) : ℕ → R) atTop atTop 
goal: Filter.Tendsto Nat.cast Filter.atTop Filter.atTop

full_name: Filter.Eventually.natCast_atTop
code: theorem Filter.Eventually.natCast_atTop [OrderedSemiring R] [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atTop, p x) : ∀ᶠ (n : ℕ) in atTop, p n 
goal: ∀ᶠ (n : ℕ) in Filter.atTop, p ↑n

full_name: Int.comap_cast_atTop
code: @[simp] theorem Int.comap_cast_atTop [StrictOrderedRing R] [Archimedean R] :
    comap ((↑) : ℤ → R) atTop = atTop 
goal: Filter.comap Int.cast Filter.atTop = Filter.atTop

full_name: Int.comap_cast_atBot
code: @[simp]
theorem Int.comap_cast_atBot [StrictOrderedRing R] [Archimedean R] :
    comap ((↑) : ℤ → R) atBot = atBot 
goal: Filter.comap Int.cast Filter.atBot = Filter.atBot

full_name: tendsto_intCast_atTop_iff
code: theorem tendsto_intCast_atTop_iff [StrictOrderedRing R] [Archimedean R] {f : α → ℤ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atTop ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun n => ↑(f n)) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop

full_name: tendsto_intCast_atBot_iff
code: theorem tendsto_intCast_atBot_iff [StrictOrderedRing R] [Archimedean R] {f : α → ℤ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atBot ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun n => ↑(f n)) l Filter.atBot ↔ Filter.Tendsto f l Filter.atBot

full_name: tendsto_intCast_atTop_atTop
code: theorem tendsto_intCast_atTop_atTop [StrictOrderedRing R] [Archimedean R] :
    Tendsto ((↑) : ℤ → R) atTop atTop 
goal: Filter.Tendsto Int.cast Filter.atTop Filter.atTop

full_name: Filter.Eventually.intCast_atTop
code: theorem Filter.Eventually.intCast_atTop [StrictOrderedRing R] [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atTop, p x) : ∀ᶠ (n : ℤ) in atTop, p n 
goal: ∀ᶠ (n : ℤ) in Filter.atTop, p ↑n

full_name: Filter.Eventually.intCast_atBot
code: theorem Filter.Eventually.intCast_atBot [StrictOrderedRing R] [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atBot, p x) : ∀ᶠ (n : ℤ) in atBot, p n 
goal: ∀ᶠ (n : ℤ) in Filter.atBot, p ↑n

full_name: Rat.comap_cast_atTop
code: @[simp]
theorem Rat.comap_cast_atTop [LinearOrderedField R] [Archimedean R] :
    comap ((↑) : ℚ → R) atTop = atTop 
goal: Filter.comap Rat.cast Filter.atTop = Filter.atTop

full_name: Rat.comap_cast_atBot
code: @[simp] theorem Rat.comap_cast_atBot [LinearOrderedField R] [Archimedean R] :
    comap ((↑) : ℚ → R) atBot = atBot 
goal: Filter.comap Rat.cast Filter.atBot = Filter.atBot

full_name: tendsto_ratCast_atTop_iff
code: theorem tendsto_ratCast_atTop_iff [LinearOrderedField R] [Archimedean R] {f : α → ℚ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atTop ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun n => ↑(f n)) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop

full_name: tendsto_ratCast_atBot_iff
code: theorem tendsto_ratCast_atBot_iff [LinearOrderedField R] [Archimedean R] {f : α → ℚ}
    {l : Filter α} : Tendsto (fun n => (f n : R)) l atBot ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun n => ↑(f n)) l Filter.atBot ↔ Filter.Tendsto f l Filter.atBot

full_name: Filter.Eventually.ratCast_atTop
code: theorem Filter.Eventually.ratCast_atTop [LinearOrderedField R] [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atTop, p x) : ∀ᶠ (n : ℚ) in atTop, p n 
goal: ∀ᶠ (n : ℚ) in Filter.atTop, p ↑n

full_name: Filter.Eventually.ratCast_atBot
code: theorem Filter.Eventually.ratCast_atBot [LinearOrderedField R] [Archimedean R] {p : R → Prop}
    (h : ∀ᶠ (x : R) in atBot, p x) : ∀ᶠ (n : ℚ) in atBot, p n 
goal: ∀ᶠ (n : ℚ) in Filter.atBot, p ↑n

full_name: atTop_hasAntitoneBasis_of_archimedean
code: theorem atTop_hasAntitoneBasis_of_archimedean [OrderedSemiring R] [Archimedean R] :
    (atTop : Filter R).HasAntitoneBasis fun n : ℕ => Ici n 
goal: Filter.atTop.HasAntitoneBasis fun n => Set.Ici ↑n

full_name: atTop_hasCountableBasis_of_archimedean
code: theorem atTop_hasCountableBasis_of_archimedean [StrictOrderedSemiring R] [Archimedean R] :
    (atTop : Filter R).HasCountableBasis (fun _ : ℕ => True) fun n => Ici n 
goal: Filter.atTop.HasCountableBasis (fun x => True) fun n => Set.Ici ↑n

full_name: atBot_hasCountableBasis_of_archimedean
code: theorem atBot_hasCountableBasis_of_archimedean [LinearOrderedRing R] [Archimedean R] :
    (atBot : Filter R).HasCountableBasis (fun _ : ℤ => True) fun m => Iic m 
goal: Filter.atBot.HasCountableBasis (fun x => True) fun m => Set.Iic ↑m

full_name: atTop_isCountablyGenerated_of_archimedean
code: instance (priority := 100) atTop_isCountablyGenerated_of_archimedean [StrictOrderedSemiring R]
    [Archimedean R] : (atTop : Filter R).IsCountablyGenerated 
goal: Filter.atTop.IsCountablyGenerated

full_name: atBot_isCountablyGenerated_of_archimedean
code: instance (priority := 100) atBot_isCountablyGenerated_of_archimedean [LinearOrderedRing R]
    [Archimedean R] : (atBot : Filter R).IsCountablyGenerated 
goal: Filter.atBot.IsCountablyGenerated

full_name: Filter.Tendsto.const_mul_atTop'
code: /-- If a function tends to infinity along a filter, then this function multiplied by a positive
constant (on the left) also tends to infinity. The archimedean assumption is convenient to get a
statement that works on `ℕ`, `ℤ` and `ℝ`, although not necessary (a version in ordered fields is
given in `Filter.Tendsto.const_mul_atTop`). -/
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 tends to infinity along a filter, then this function multiplied by a positive
constant (on the right) also tends to infinity. The archimedean assumption is convenient to get a
statement that works on `ℕ`, `ℤ` and `ℝ`, although not necessary (a version in ordered fields is
given in `Filter.Tendsto.atTop_mul_const`). -/
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_mul_const_of_neg'
code: /-- See also `Filter.Tendsto.atTop_mul_const_of_neg` for a version of this lemma for
`LinearOrderedField`s which does not require the `Archimedean` assumption. -/
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.atBot_mul_const'
code: /-- See also `Filter.Tendsto.atBot_mul_const` for a version of this lemma for
`LinearOrderedField`s which does not require the `Archimedean` assumption. -/
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_mul_const_of_neg'
code: /-- See also `Filter.Tendsto.atBot_mul_const_of_neg` for a version of this lemma for
`LinearOrderedField`s which does not require the `Archimedean` assumption. -/
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.atTop_nsmul_const
code: theorem Tendsto.atTop_nsmul_const {f : α → ℕ} (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_nsmul_neg_const
code: theorem Tendsto.atTop_nsmul_neg_const {f : α → ℕ} (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_zsmul_const
code: theorem Tendsto.atTop_zsmul_const {f : α → ℤ} (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_zsmul_neg_const
code: theorem Tendsto.atTop_zsmul_neg_const {f : α → ℤ} (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.atBot_zsmul_const
code: theorem Tendsto.atBot_zsmul_const {f : α → ℤ} (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_zsmul_neg_const
code: theorem Tendsto.atBot_zsmul_neg_const {f : α → ℤ} (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