File: Mathlib/Topology/Instances/NNReal.lean

full_name: NNReal.instTopologicalSpace
code: instance : TopologicalSpace ℝ≥0 
goal: TopologicalSpace NNReal

full_name: NNReal.instTopologicalSemiring
code: instance : TopologicalSemiring ℝ≥0 
goal: TopologicalSemiring NNReal

full_name: NNReal.instSecondCountableTopology
code: instance : SecondCountableTopology ℝ≥0 
goal: SecondCountableTopology NNReal

full_name: NNReal.instOrderTopology
code: instance : OrderTopology ℝ≥0 
goal: OrderTopology NNReal

full_name: NNReal.instCompleteSpace
code: instance : CompleteSpace ℝ≥0 
goal: CompleteSpace NNReal

full_name: NNReal.instContinuousStar
code: instance : ContinuousStar ℝ≥0 
goal: ContinuousStar NNReal

full_name: continuous_real_toNNReal
code: theorem _root_.continuous_real_toNNReal : Continuous Real.toNNReal 
goal: Continuous Real.toNNReal

full_name: ContinuousMap.realToNNReal_apply
code: /-- `Real.toNNReal` bundled as a continuous map for convenience. -/
@[simps (config := .asFn)]
noncomputable def _root_.ContinuousMap.realToNNReal : C(ℝ, ℝ≥0) 
goal: ⇑ContinuousMap.realToNNReal = Real.toNNReal

full_name: ContinuousMap.realToNNReal
code: /-- `Real.toNNReal` bundled as a continuous map for convenience. -/
@[simps (config := .asFn)]
noncomputable def _root_.ContinuousMap.realToNNReal : C(ℝ, ℝ≥0) 
goal: C(ℝ, NNReal)

full_name: NNReal.continuous_coe
code: theorem continuous_coe : Continuous ((↑) : ℝ≥0 → ℝ) 
goal: Continuous NNReal.toReal

full_name: ContinuousMap.coeNNRealReal_apply
code: /-- Embedding of `ℝ≥0` to `ℝ` as a bundled continuous map. -/
@[simps (config := .asFn)]
def _root_.ContinuousMap.coeNNRealReal : C(ℝ≥0, ℝ) 
goal: ⇑ContinuousMap.coeNNRealReal = NNReal.toReal

full_name: ContinuousMap.coeNNRealReal
code: /-- Embedding of `ℝ≥0` to `ℝ` as a bundled continuous map. -/
@[simps (config := .asFn)]
def _root_.ContinuousMap.coeNNRealReal : C(ℝ≥0, ℝ) 
goal: C(NNReal, ℝ)

full_name: NNReal.ContinuousMap.canLift
code: instance ContinuousMap.canLift {X : Type*} [TopologicalSpace X] :
    CanLift C(X, ℝ) C(X, ℝ≥0) ContinuousMap.coeNNRealReal.comp fun f => ∀ x, 0 ≤ f x 
goal: CanLift C(X, ℝ) C(X, NNReal) ContinuousMap.coeNNRealReal.comp fun f => ∀ (x : X), 0 ≤ f x

full_name: NNReal.tendsto_coe
code: @[simp, norm_cast]
theorem tendsto_coe {f : Filter α} {m : α → ℝ≥0} {x : ℝ≥0} :
    Tendsto (fun a => (m a : ℝ)) f (𝓝 (x : ℝ)) ↔ Tendsto m f (𝓝 x) 
goal: Filter.Tendsto (fun a => ↑(m a)) f (𝓝 ↑x) ↔ Filter.Tendsto m f (𝓝 x)

full_name: NNReal.tendsto_coe'
code: theorem tendsto_coe' {f : Filter α} [NeBot f] {m : α → ℝ≥0} {x : ℝ} :
    Tendsto (fun a => m a : α → ℝ) f (𝓝 x) ↔ ∃ hx : 0 ≤ x, Tendsto m f (𝓝 ⟨x, hx⟩) 
goal: Filter.Tendsto (fun a => ↑(m a)) f (𝓝 x) ↔ ∃ (hx : 0 ≤ x), Filter.Tendsto m f (𝓝 ⟨x, hx⟩)

full_name: NNReal.map_coe_atTop
code: @[simp] theorem map_coe_atTop : map toReal atTop = atTop 
goal: Filter.map NNReal.toReal Filter.atTop = Filter.atTop

full_name: NNReal.comap_coe_atTop
code: @[simp]
theorem comap_coe_atTop : comap toReal atTop = atTop 
goal: Filter.comap NNReal.toReal Filter.atTop = Filter.atTop

full_name: NNReal.tendsto_coe_atTop
code: @[simp, norm_cast]
theorem tendsto_coe_atTop {f : Filter α} {m : α → ℝ≥0} :
    Tendsto (fun a => (m a : ℝ)) f atTop ↔ Tendsto m f atTop 
goal: Filter.Tendsto (fun a => ↑(m a)) f Filter.atTop ↔ Filter.Tendsto m f Filter.atTop

full_name: tendsto_real_toNNReal
code: theorem _root_.tendsto_real_toNNReal {f : Filter α} {m : α → ℝ} {x : ℝ} (h : Tendsto m f (𝓝 x)) :
    Tendsto (fun a => Real.toNNReal (m a)) f (𝓝 (Real.toNNReal x)) 
goal: Filter.Tendsto (fun a => (m a).toNNReal) f (𝓝 x.toNNReal)

full_name: Real.map_toNNReal_atTop
code: @[simp]
theorem _root_.Real.map_toNNReal_atTop : map Real.toNNReal atTop = atTop 
goal: Filter.map Real.toNNReal Filter.atTop = Filter.atTop

full_name: tendsto_real_toNNReal_atTop
code: theorem _root_.tendsto_real_toNNReal_atTop : Tendsto Real.toNNReal atTop atTop 
goal: Filter.Tendsto Real.toNNReal Filter.atTop Filter.atTop

full_name: Real.comap_toNNReal_atTop
code: @[simp]
theorem _root_.Real.comap_toNNReal_atTop : comap Real.toNNReal atTop = atTop 
goal: Filter.comap Real.toNNReal Filter.atTop = Filter.atTop

full_name: Real.tendsto_toNNReal_atTop_iff
code: @[simp]
theorem _root_.Real.tendsto_toNNReal_atTop_iff {l : Filter α} {f : α → ℝ} :
    Tendsto (fun x ↦ (f x).toNNReal) l atTop ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => (f x).toNNReal) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop

full_name: Real.tendsto_toNNReal_atTop
code: theorem _root_.Real.tendsto_toNNReal_atTop : Tendsto Real.toNNReal atTop atTop 
goal: Filter.Tendsto Real.toNNReal Filter.atTop Filter.atTop

full_name: NNReal.nhds_zero
code: theorem nhds_zero : 𝓝 (0 : ℝ≥0) = ⨅ (a : ℝ≥0) (_ : a ≠ 0), 𝓟 (Iio a) 
goal: 𝓝 0 = ⨅ a, ⨅ (_ : a ≠ 0), 𝓟 (Set.Iio a)

full_name: NNReal.nhds_zero_basis
code: theorem nhds_zero_basis : (𝓝 (0 : ℝ≥0)).HasBasis (fun a : ℝ≥0 => 0 < a) fun a => Iio a 
goal: (𝓝 0).HasBasis (fun a => 0 < a) fun a => Set.Iio a

full_name: NNReal.instContinuousSub
code: instance : ContinuousSub ℝ≥0 
goal: ContinuousSub NNReal

full_name: NNReal.instHasContinuousInv₀
code: instance : HasContinuousInv₀ ℝ≥0 
goal: HasContinuousInv₀ NNReal

full_name: NNReal.instContinuousSMulOfReal
code: instance [TopologicalSpace α] [MulAction ℝ α] [ContinuousSMul ℝ α] :
    ContinuousSMul ℝ≥0 α 
goal: ContinuousSMul NNReal α

full_name: NNReal.hasSum_coe
code: @[norm_cast]
theorem hasSum_coe {f : α → ℝ≥0} {r : ℝ≥0} : HasSum (fun a => (f a : ℝ)) (r : ℝ) ↔ HasSum f r 
goal: HasSum (fun a => ↑(f a)) ↑r ↔ HasSum f r

full_name: HasSum.toNNReal
code: protected theorem _root_.HasSum.toNNReal {f : α → ℝ} {y : ℝ} (hf₀ : ∀ n, 0 ≤ f n)
    (hy : HasSum f y) : HasSum (fun x => Real.toNNReal (f x)) y.toNNReal 
goal: HasSum (fun x => (f x).toNNReal) y.toNNReal

full_name: NNReal.hasSum_real_toNNReal_of_nonneg
code: theorem hasSum_real_toNNReal_of_nonneg {f : α → ℝ} (hf_nonneg : ∀ n, 0 ≤ f n) (hf : Summable f) :
    HasSum (fun n => Real.toNNReal (f n)) (Real.toNNReal (∑' n, f n)) 
goal: HasSum (fun n => (f n).toNNReal) (∑' (n : α), f n).toNNReal

full_name: NNReal.summable_coe
code: @[norm_cast]
theorem summable_coe {f : α → ℝ≥0} : (Summable fun a => (f a : ℝ)) ↔ Summable f 
goal: (Summable fun a => ↑(f a)) ↔ Summable f

full_name: NNReal.summable_mk
code: theorem summable_mk {f : α → ℝ} (hf : ∀ n, 0 ≤ f n) :
    (@Summable ℝ≥0 _ _ _ fun n => ⟨f n, hf n⟩) ↔ Summable f 
goal: (Summable fun n => ⟨f n, ⋯⟩) ↔ Summable f

full_name: NNReal.coe_tsum
code: @[norm_cast]
theorem coe_tsum {f : α → ℝ≥0} : ↑(∑' a, f a) = ∑' a, (f a : ℝ) 
goal: ↑(∑' (a : α), f a) = ∑' (a : α), ↑(f a)

full_name: NNReal.coe_tsum_of_nonneg
code: theorem coe_tsum_of_nonneg {f : α → ℝ} (hf₁ : ∀ n, 0 ≤ f n) :
    (⟨∑' n, f n, tsum_nonneg hf₁⟩ : ℝ≥0) = (∑' n, ⟨f n, hf₁ n⟩ : ℝ≥0) 
goal: ⟨∑' (n : α), f n, ⋯⟩ = ∑' (n : α), ⟨f n, ⋯⟩

full_name: NNReal.tsum_mul_left
code: nonrec theorem tsum_mul_left (a : ℝ≥0) (f : α → ℝ≥0) : ∑' x, a * f x = a * ∑' x, f x 
goal: ∑' (x : α), a * f x = a * ∑' (x : α), f x

full_name: NNReal.tsum_mul_right
code: nonrec theorem tsum_mul_right (f : α → ℝ≥0) (a : ℝ≥0) : ∑' x, f x * a = (∑' x, f x) * a 
goal: ∑' (x : α), f x * a = (∑' (x : α), f x) * a

full_name: NNReal.summable_comp_injective
code: theorem summable_comp_injective {β : Type*} {f : α → ℝ≥0} (hf : Summable f) {i : β → α}
    (hi : Function.Injective i) : Summable (f ∘ i) 
goal: Summable (f ∘ i)

full_name: NNReal.summable_nat_add
code: theorem summable_nat_add (f : ℕ → ℝ≥0) (hf : Summable f) (k : ℕ) : Summable fun i => f (i + k) 
goal: Summable fun i => f (i + k)

full_name: NNReal.summable_nat_add_iff
code: nonrec theorem summable_nat_add_iff {f : ℕ → ℝ≥0} (k : ℕ) :
    (Summable fun i => f (i + k)) ↔ Summable f 
goal: (Summable fun i => f (i + k)) ↔ Summable f

full_name: NNReal.hasSum_nat_add_iff
code: nonrec theorem hasSum_nat_add_iff {f : ℕ → ℝ≥0} (k : ℕ) {a : ℝ≥0} :
    HasSum (fun n => f (n + k)) a ↔ HasSum f (a + ∑ i ∈ range k, f i) 
goal: HasSum (fun n => f (n + k)) a ↔ HasSum f (a + ∑ i ∈ Finset.range k, f i)

full_name: NNReal.sum_add_tsum_nat_add
code: theorem sum_add_tsum_nat_add {f : ℕ → ℝ≥0} (k : ℕ) (hf : Summable f) :
    ∑' i, f i = (∑ i ∈ range k, f i) + ∑' i, f (i + k) 
goal: ∑' (i : ℕ), f i = ∑ i ∈ Finset.range k, f i + ∑' (i : ℕ), f (i + k)

full_name: NNReal.iInf_real_pos_eq_iInf_nnreal_pos
code: theorem iInf_real_pos_eq_iInf_nnreal_pos [CompleteLattice α] {f : ℝ → α} :
    ⨅ (n : ℝ) (_ : 0 < n), f n = ⨅ (n : ℝ≥0) (_ : 0 < n), f n 
goal: ⨅ n, ⨅ (_ : 0 < n), f n = ⨅ n, ⨅ (_ : 0 < n), f ↑n

full_name: NNReal.tendsto_cofinite_zero_of_summable
code: theorem tendsto_cofinite_zero_of_summable {α} {f : α → ℝ≥0} (hf : Summable f) :
    Tendsto f cofinite (𝓝 0) 
goal: Filter.Tendsto f Filter.cofinite (𝓝 0)

full_name: NNReal.tendsto_atTop_zero_of_summable
code: theorem tendsto_atTop_zero_of_summable {f : ℕ → ℝ≥0} (hf : Summable f) : Tendsto f atTop (𝓝 0) 
goal: Filter.Tendsto f Filter.atTop (𝓝 0)

full_name: NNReal.tendsto_tsum_compl_atTop_zero
code: /-- The sum over the complement of a finset tends to `0` when the finset grows to cover the whole
space. This does not need a summability assumption, as otherwise all sums are zero. -/
nonrec theorem tendsto_tsum_compl_atTop_zero {α : Type*} (f : α → ℝ≥0) :
    Tendsto (fun s : Finset α => ∑' b : { x // x ∉ s }, f b) atTop (𝓝 0) 
goal: Filter.Tendsto (fun s => ∑' (b : { x // x ∉ s }), f ↑b) Filter.atTop (𝓝 0)

full_name: NNReal.powOrderIso
code: /-- `x ↦ x ^ n` as an order isomorphism of `ℝ≥0`. -/
def powOrderIso (n : ℕ) (hn : n ≠ 0) : ℝ≥0 ≃o ℝ≥0 
goal: NNReal ≃o NNReal

full_name: Real.tendsto_of_bddAbove_monotone
code: /-- A monotone, bounded above sequence `f : ℕ → ℝ` has a finite limit. -/
theorem _root_.Real.tendsto_of_bddAbove_monotone {f : ℕ → ℝ} (h_bdd : BddAbove (Set.range f))
    (h_mon : Monotone f) : ∃ r : ℝ, Tendsto f atTop (𝓝 r) 
goal: ∃ r, Filter.Tendsto f Filter.atTop (𝓝 r)

full_name: Real.tendsto_of_bddBelow_antitone
code: /-- An antitone, bounded below sequence `f : ℕ → ℝ` has a finite limit. -/
theorem _root_.Real.tendsto_of_bddBelow_antitone {f : ℕ → ℝ} (h_bdd : BddBelow (Set.range f))
    (h_ant : Antitone f) : ∃ r : ℝ, Tendsto f atTop (𝓝 r) 
goal: ∃ r, Filter.Tendsto f Filter.atTop (𝓝 r)

full_name: NNReal.tendsto_of_antitone
code: /-- An antitone sequence `f : ℕ → ℝ≥0` has a finite limit. -/
theorem tendsto_of_antitone {f : ℕ → ℝ≥0} (h_ant : Antitone f) :
    ∃ r : ℝ≥0, Tendsto f atTop (𝓝 r) 
goal: ∃ r, Filter.Tendsto f Filter.atTop (𝓝 r)

full_name: NNReal.instProperSpace
code: instance instProperSpace : ProperSpace ℝ≥0 
goal: ProperSpace NNReal