File: Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean

full_name: Real.borel_eq_generateFrom_Ioo_rat
code: theorem borel_eq_generateFrom_Ioo_rat :
    borel ℝ = .generateFrom (⋃ (a : ℚ) (b : ℚ) (_ : a < b), {Ioo (a : ℝ) (b : ℝ)}) 
goal: borel ℝ = MeasurableSpace.generateFrom (⋃ a, ⋃ b, ⋃ (_ : a < b), {Set.Ioo ↑a ↑b})

full_name: Real.borel_eq_generateFrom_Iio_rat
code: theorem borel_eq_generateFrom_Iio_rat : borel ℝ = .generateFrom (⋃ a : ℚ, {Iio (a : ℝ)}) 
goal: borel ℝ = MeasurableSpace.generateFrom (⋃ a, {Set.Iio ↑a})

full_name: Real.borel_eq_generateFrom_Ioi_rat
code: theorem borel_eq_generateFrom_Ioi_rat : borel ℝ = .generateFrom (⋃ a : ℚ, {Ioi (a : ℝ)}) 
goal: borel ℝ = MeasurableSpace.generateFrom (⋃ a, {Set.Ioi ↑a})

full_name: Real.borel_eq_generateFrom_Iic_rat
code: theorem borel_eq_generateFrom_Iic_rat : borel ℝ = .generateFrom (⋃ a : ℚ, {Iic (a : ℝ)}) 
goal: borel ℝ = MeasurableSpace.generateFrom (⋃ a, {Set.Iic ↑a})

full_name: Real.borel_eq_generateFrom_Ici_rat
code: theorem borel_eq_generateFrom_Ici_rat : borel ℝ = .generateFrom (⋃ a : ℚ, {Ici (a : ℝ)}) 
goal: borel ℝ = MeasurableSpace.generateFrom (⋃ a, {Set.Ici ↑a})

full_name: Real.isPiSystem_Ioo_rat
code: theorem isPiSystem_Ioo_rat :
    IsPiSystem (⋃ (a : ℚ) (b : ℚ) (_ : a < b), {Ioo (a : ℝ) (b : ℝ)}) 
goal: IsPiSystem (⋃ a, ⋃ b, ⋃ (_ : a < b), {Set.Ioo ↑a ↑b})

full_name: Real.isPiSystem_Iio_rat
code: theorem isPiSystem_Iio_rat : IsPiSystem (⋃ a : ℚ, {Iio (a : ℝ)}) 
goal: IsPiSystem (⋃ a, {Set.Iio ↑a})

full_name: Real.isPiSystem_Ioi_rat
code: theorem isPiSystem_Ioi_rat : IsPiSystem (⋃ a : ℚ, {Ioi (a : ℝ)}) 
goal: IsPiSystem (⋃ a, {Set.Ioi ↑a})

full_name: Real.isPiSystem_Iic_rat
code: theorem isPiSystem_Iic_rat : IsPiSystem (⋃ a : ℚ, {Iic (a : ℝ)}) 
goal: IsPiSystem (⋃ a, {Set.Iic ↑a})

full_name: Real.isPiSystem_Ici_rat
code: theorem isPiSystem_Ici_rat : IsPiSystem (⋃ a : ℚ, {Ici (a : ℝ)}) 
goal: IsPiSystem (⋃ a, {Set.Ici ↑a})

full_name: Real.finiteSpanningSetsInIooRat
code: /-- The intervals `(-(n + 1), (n + 1))` form a finite spanning sets in the set of open intervals
with rational endpoints for a locally finite measure `μ` on `ℝ`. -/
def finiteSpanningSetsInIooRat (μ : Measure ℝ) [IsLocallyFiniteMeasure μ] :
    μ.FiniteSpanningSetsIn (⋃ (a : ℚ) (b : ℚ) (_ : a < b), {Ioo (a : ℝ) (b : ℝ)}) 
goal: μ.FiniteSpanningSetsIn (⋃ a, ⋃ b, ⋃ (_ : a < b), {Set.Ioo ↑a ↑b})

full_name: Real.measure_ext_Ioo_rat
code: theorem measure_ext_Ioo_rat {μ ν : Measure ℝ} [IsLocallyFiniteMeasure μ]
    (h : ∀ a b : ℚ, μ (Ioo a b) = ν (Ioo a b)) : μ = ν 
goal: μ = ν

full_name: measurable_real_toNNReal
code: @[measurability, fun_prop]
theorem measurable_real_toNNReal : Measurable Real.toNNReal 
goal: Measurable Real.toNNReal

full_name: Measurable.real_toNNReal
code: @[measurability, fun_prop]
theorem Measurable.real_toNNReal {f : α → ℝ} (hf : Measurable f) :
    Measurable fun x => Real.toNNReal (f x) 
goal: Measurable fun x => (f x).toNNReal

full_name: AEMeasurable.real_toNNReal
code: @[measurability, fun_prop]
theorem AEMeasurable.real_toNNReal {f : α → ℝ} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => Real.toNNReal (f x)) μ 
goal: AEMeasurable (fun x => (f x).toNNReal) μ

full_name: measurable_coe_nnreal_real
code: @[measurability]
theorem measurable_coe_nnreal_real : Measurable ((↑) : ℝ≥0 → ℝ) 
goal: Measurable NNReal.toReal

full_name: Measurable.coe_nnreal_real
code: @[measurability, fun_prop]
theorem Measurable.coe_nnreal_real {f : α → ℝ≥0} (hf : Measurable f) :
    Measurable fun x => (f x : ℝ) 
goal: Measurable fun x => ↑(f x)

full_name: AEMeasurable.coe_nnreal_real
code: @[measurability, fun_prop]
theorem AEMeasurable.coe_nnreal_real {f : α → ℝ≥0} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => (f x : ℝ)) μ 
goal: AEMeasurable (fun x => ↑(f x)) μ

full_name: measurable_coe_nnreal_ennreal
code: @[measurability]
theorem measurable_coe_nnreal_ennreal : Measurable ((↑) : ℝ≥0 → ℝ≥0∞) 
goal: Measurable ENNReal.ofNNReal

full_name: Measurable.coe_nnreal_ennreal
code: @[measurability, fun_prop]
theorem Measurable.coe_nnreal_ennreal {f : α → ℝ≥0} (hf : Measurable f) :
    Measurable fun x => (f x : ℝ≥0∞) 
goal: Measurable fun x => ↑(f x)

full_name: AEMeasurable.coe_nnreal_ennreal
code: @[measurability, fun_prop]
theorem AEMeasurable.coe_nnreal_ennreal {f : α → ℝ≥0} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => (f x : ℝ≥0∞)) μ 
goal: AEMeasurable (fun x => ↑(f x)) μ

full_name: Measurable.ennreal_ofReal
code: @[measurability, fun_prop]
theorem Measurable.ennreal_ofReal {f : α → ℝ} (hf : Measurable f) :
    Measurable fun x => ENNReal.ofReal (f x) 
goal: Measurable fun x => ENNReal.ofReal (f x)

full_name: AEMeasurable.ennreal_ofReal
code: @[measurability, fun_prop]
lemma AEMeasurable.ennreal_ofReal {f : α → ℝ} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x ↦ ENNReal.ofReal (f x)) μ 
goal: AEMeasurable (fun x => ENNReal.ofReal (f x)) μ

full_name: measurable_coe_nnreal_real_iff
code: @[simp, norm_cast]
theorem measurable_coe_nnreal_real_iff {f : α → ℝ≥0} :
    Measurable (fun x => f x : α → ℝ) ↔ Measurable f 
goal: (Measurable fun x => ↑(f x)) ↔ Measurable f

full_name: aemeasurable_coe_nnreal_real_iff
code: @[simp, norm_cast]
theorem aemeasurable_coe_nnreal_real_iff {f : α → ℝ≥0} {μ : Measure α} :
    AEMeasurable (fun x => f x : α → ℝ) μ ↔ AEMeasurable f μ 
goal: AEMeasurable (fun x => ↑(f x)) μ ↔ AEMeasurable f μ

full_name: MeasurableEquiv.ennrealEquivNNReal
code: /-- The set of finite `ℝ≥0∞` numbers is `MeasurableEquiv` to `ℝ≥0`. -/
def MeasurableEquiv.ennrealEquivNNReal : { r : ℝ≥0∞ | r ≠ ∞ } ≃ᵐ ℝ≥0 
goal: ↑{r | r ≠ ⊤} ≃ᵐ ℝ≥0

full_name: ENNReal.measurable_of_measurable_nnreal
code: theorem measurable_of_measurable_nnreal {f : ℝ≥0∞ → α} (h : Measurable fun p : ℝ≥0 => f p) :
    Measurable f 
goal: Measurable f

full_name: ENNReal.ennrealEquivSum
code: /-- `ℝ≥0∞` is `MeasurableEquiv` to `ℝ≥0 ⊕ Unit`. -/
def ennrealEquivSum : ℝ≥0∞ ≃ᵐ ℝ≥0 ⊕ Unit 
goal: ℝ≥0∞ ≃ᵐ ℝ≥0 ⊕ Unit

full_name: ENNReal.measurable_of_measurable_nnreal_prod
code: theorem measurable_of_measurable_nnreal_prod [MeasurableSpace β] [MeasurableSpace γ]
    {f : ℝ≥0∞ × β → γ} (H₁ : Measurable fun p : ℝ≥0 × β => f (p.1, p.2))
    (H₂ : Measurable fun x => f (∞, x)) : Measurable f 
goal: Measurable f

full_name: ENNReal.measurable_of_measurable_nnreal_nnreal
code: theorem measurable_of_measurable_nnreal_nnreal [MeasurableSpace β] {f : ℝ≥0∞ × ℝ≥0∞ → β}
    (h₁ : Measurable fun p : ℝ≥0 × ℝ≥0 => f (p.1, p.2)) (h₂ : Measurable fun r : ℝ≥0 => f (∞, r))
    (h₃ : Measurable fun r : ℝ≥0 => f (r, ∞)) : Measurable f 
goal: Measurable f

full_name: ENNReal.measurable_ofReal
code: @[measurability]
theorem measurable_ofReal : Measurable ENNReal.ofReal 
goal: Measurable ENNReal.ofReal

full_name: ENNReal.measurable_toReal
code: @[measurability]
theorem measurable_toReal : Measurable ENNReal.toReal 
goal: Measurable ENNReal.toReal

full_name: ENNReal.measurable_toNNReal
code: @[measurability]
theorem measurable_toNNReal : Measurable ENNReal.toNNReal 
goal: Measurable ENNReal.toNNReal

full_name: ENNReal.instMeasurableMul₂
code: instance instMeasurableMul₂ : MeasurableMul₂ ℝ≥0∞ 
goal: MeasurableMul₂ ℝ≥0∞

full_name: ENNReal.instMeasurableSub₂
code: instance instMeasurableSub₂ : MeasurableSub₂ ℝ≥0∞ 
goal: MeasurableSub₂ ℝ≥0∞

full_name: ENNReal.instMeasurableInv
code: instance instMeasurableInv : MeasurableInv ℝ≥0∞ 
goal: MeasurableInv ℝ≥0∞

full_name: ENNReal.instMeasurableSMulNNReal
code: instance : MeasurableSMul ℝ≥0 ℝ≥0∞ 
goal: MeasurableSMul ℝ≥0 ℝ≥0∞

full_name: ENNReal.measurable_of_tendsto'
code: /-- A limit (over a general filter) of measurable `ℝ≥0∞` valued functions is measurable. -/
theorem measurable_of_tendsto' {ι : Type*} {f : ι → α → ℝ≥0∞} {g : α → ℝ≥0∞} (u : Filter ι)
    [NeBot u] [IsCountablyGenerated u] (hf : ∀ i, Measurable (f i)) (lim : Tendsto f u (𝓝 g)) :
    Measurable g 
goal: Measurable g

full_name: ENNReal.measurable_of_tendsto
code: /-- A sequential limit of measurable `ℝ≥0∞` valued functions is measurable. -/
theorem measurable_of_tendsto {f : ℕ → α → ℝ≥0∞} {g : α → ℝ≥0∞} (hf : ∀ i, Measurable (f i))
    (lim : Tendsto f atTop (𝓝 g)) : Measurable g 
goal: Measurable g

full_name: ENNReal.aemeasurable_of_tendsto'
code: /-- A limit (over a general filter) of a.e.-measurable `ℝ≥0∞` valued functions is
a.e.-measurable. -/
lemma aemeasurable_of_tendsto' {ι : Type*} {f : ι → α → ℝ≥0∞} {g : α → ℝ≥0∞}
    {μ : Measure α} (u : Filter ι) [NeBot u] [IsCountablyGenerated u]
    (hf : ∀ i, AEMeasurable (f i) μ) (hlim : ∀ᵐ a ∂μ, Tendsto (fun i ↦ f i a) u (𝓝 (g a))) :
    AEMeasurable g μ 
goal: AEMeasurable g μ

full_name: ENNReal.aemeasurable_of_tendsto
code: /-- A limit of a.e.-measurable `ℝ≥0∞` valued functions is a.e.-measurable. -/
lemma aemeasurable_of_tendsto {f : ℕ → α → ℝ≥0∞} {g : α → ℝ≥0∞} {μ : Measure α}
    (hf : ∀ i, AEMeasurable (f i) μ) (hlim : ∀ᵐ a ∂μ, Tendsto (fun i ↦ f i a) atTop (𝓝 (g a))) :
    AEMeasurable g μ 
goal: AEMeasurable g μ

full_name: Measurable.ennreal_toNNReal
code: @[measurability, fun_prop]
theorem Measurable.ennreal_toNNReal {f : α → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun x => (f x).toNNReal 
goal: Measurable fun x => (f x).toNNReal

full_name: AEMeasurable.ennreal_toNNReal
code: @[measurability, fun_prop]
theorem AEMeasurable.ennreal_toNNReal {f : α → ℝ≥0∞} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => (f x).toNNReal) μ 
goal: AEMeasurable (fun x => (f x).toNNReal) μ

full_name: measurable_coe_nnreal_ennreal_iff
code: @[simp, norm_cast]
theorem measurable_coe_nnreal_ennreal_iff {f : α → ℝ≥0} :
    (Measurable fun x => (f x : ℝ≥0∞)) ↔ Measurable f 
goal: (Measurable fun x => ↑(f x)) ↔ Measurable f

full_name: aemeasurable_coe_nnreal_ennreal_iff
code: @[simp, norm_cast]
theorem aemeasurable_coe_nnreal_ennreal_iff {f : α → ℝ≥0} {μ : Measure α} :
    AEMeasurable (fun x => (f x : ℝ≥0∞)) μ ↔ AEMeasurable f μ 
goal: AEMeasurable (fun x => ↑(f x)) μ ↔ AEMeasurable f μ

full_name: Measurable.ennreal_toReal
code: @[measurability, fun_prop]
theorem Measurable.ennreal_toReal {f : α → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun x => ENNReal.toReal (f x) 
goal: Measurable fun x => (f x).toReal

full_name: AEMeasurable.ennreal_toReal
code: @[measurability, fun_prop]
theorem AEMeasurable.ennreal_toReal {f : α → ℝ≥0∞} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => ENNReal.toReal (f x)) μ 
goal: AEMeasurable (fun x => (f x).toReal) μ

full_name: Measurable.ennreal_tsum
code: /-- note: `ℝ≥0∞` can probably be generalized in a future version of this lemma. -/
@[measurability, fun_prop]
theorem Measurable.ennreal_tsum {ι} [Countable ι] {f : ι → α → ℝ≥0∞} (h : ∀ i, Measurable (f i)) :
    Measurable fun x => ∑' i, f i x 
goal: Measurable fun x => ∑' (i : ι), f i x

full_name: Measurable.ennreal_tsum'
code: @[measurability, fun_prop]
theorem Measurable.ennreal_tsum' {ι} [Countable ι] {f : ι → α → ℝ≥0∞} (h : ∀ i, Measurable (f i)) :
    Measurable (∑' i, f i) 
goal: Measurable (∑' (i : ι), f i)

full_name: Measurable.nnreal_tsum
code: @[measurability, fun_prop]
theorem Measurable.nnreal_tsum {ι} [Countable ι] {f : ι → α → ℝ≥0} (h : ∀ i, Measurable (f i)) :
    Measurable fun x => ∑' i, f i x 
goal: Measurable fun x => ∑' (i : ι), f i x

full_name: AEMeasurable.ennreal_tsum
code: @[measurability, fun_prop]
theorem AEMeasurable.ennreal_tsum {ι} [Countable ι] {f : ι → α → ℝ≥0∞} {μ : Measure α}
    (h : ∀ i, AEMeasurable (f i) μ) : AEMeasurable (fun x => ∑' i, f i x) μ 
goal: AEMeasurable (fun x => ∑' (i : ι), f i x) μ

full_name: AEMeasurable.nnreal_tsum
code: @[measurability, fun_prop]
theorem AEMeasurable.nnreal_tsum {α : Type*} [MeasurableSpace α] {ι : Type*} [Countable ι]
    {f : ι → α → NNReal} {μ : MeasureTheory.Measure α} (h : ∀ i : ι, AEMeasurable (f i) μ) :
    AEMeasurable (fun x : α => ∑' i : ι, f i x) μ 
goal: AEMeasurable (fun x => ∑' (i : ι), f i x) μ

full_name: measurable_coe_real_ereal
code: @[measurability, fun_prop]
theorem measurable_coe_real_ereal : Measurable ((↑) : ℝ → EReal) 
goal: Measurable Real.toEReal

full_name: Measurable.coe_real_ereal
code: @[measurability]
theorem Measurable.coe_real_ereal {f : α → ℝ} (hf : Measurable f) :
    Measurable fun x => (f x : EReal) 
goal: Measurable fun x => ↑(f x)

full_name: AEMeasurable.coe_real_ereal
code: @[measurability]
theorem AEMeasurable.coe_real_ereal {f : α → ℝ} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => (f x : EReal)) μ 
goal: AEMeasurable (fun x => ↑(f x)) μ

full_name: MeasurableEquiv.erealEquivReal
code: /-- The set of finite `EReal` numbers is `MeasurableEquiv` to `ℝ`. -/
def MeasurableEquiv.erealEquivReal : ({⊥, ⊤}ᶜ : Set EReal) ≃ᵐ ℝ 
goal: ↑{⊥, ⊤}ᶜ ≃ᵐ ℝ

full_name: EReal.measurable_of_measurable_real
code: theorem EReal.measurable_of_measurable_real {f : EReal → α} (h : Measurable fun p : ℝ => f p) :
    Measurable f 
goal: Measurable f

full_name: measurable_ereal_toReal
code: @[measurability]
theorem measurable_ereal_toReal : Measurable EReal.toReal 
goal: Measurable EReal.toReal

full_name: Measurable.ereal_toReal
code: @[measurability, fun_prop]
theorem Measurable.ereal_toReal {f : α → EReal} (hf : Measurable f) :
    Measurable fun x => (f x).toReal 
goal: Measurable fun x => (f x).toReal

full_name: AEMeasurable.ereal_toReal
code: @[measurability, fun_prop]
theorem AEMeasurable.ereal_toReal {f : α → EReal} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => (f x).toReal) μ 
goal: AEMeasurable (fun x => (f x).toReal) μ

full_name: measurable_coe_ennreal_ereal
code: @[measurability]
theorem measurable_coe_ennreal_ereal : Measurable ((↑) : ℝ≥0∞ → EReal) 
goal: Measurable ENNReal.toEReal

full_name: Measurable.coe_ereal_ennreal
code: @[measurability, fun_prop]
theorem Measurable.coe_ereal_ennreal {f : α → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun x => (f x : EReal) 
goal: Measurable fun x => ↑(f x)

full_name: AEMeasurable.coe_ereal_ennreal
code: @[measurability, fun_prop]
theorem AEMeasurable.coe_ereal_ennreal {f : α → ℝ≥0∞} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => (f x : EReal)) μ 
goal: AEMeasurable (fun x => ↑(f x)) μ

full_name: NNReal.measurable_of_tendsto'
code: /-- A limit (over a general filter) of measurable `ℝ≥0` valued functions is measurable. -/
theorem measurable_of_tendsto' {ι} {f : ι → α → ℝ≥0} {g : α → ℝ≥0} (u : Filter ι) [NeBot u]
    [IsCountablyGenerated u] (hf : ∀ i, Measurable (f i)) (lim : Tendsto f u (𝓝 g)) :
    Measurable g 
goal: Measurable g

full_name: NNReal.measurable_of_tendsto
code: /-- A sequential limit of measurable `ℝ≥0` valued functions is measurable. -/
theorem measurable_of_tendsto {f : ℕ → α → ℝ≥0} {g : α → ℝ≥0} (hf : ∀ i, Measurable (f i))
    (lim : Tendsto f atTop (𝓝 g)) : Measurable g 
goal: Measurable g

full_name: exists_spanning_measurableSet_le
code: /-- If a function `f : α → ℝ≥0` is measurable and the measure is σ-finite, then there exists
spanning measurable sets with finite measure on which `f` is bounded.
See also `StronglyMeasurable.exists_spanning_measurableSet_norm_le` for functions into normed
groups. -/
theorem exists_spanning_measurableSet_le {m : MeasurableSpace α} {f : α → ℝ≥0}
    (hf : Measurable f) (μ : Measure α) [SigmaFinite μ] :
    ∃ s : ℕ → Set α,
      (∀ n, MeasurableSet (s n) ∧ μ (s n) < ∞ ∧ ∀ x ∈ s n, f x ≤ n) ∧
      ⋃ i, s i = Set.univ 
goal: ∃ s, (∀ (n : ℕ), MeasurableSet (s n) ∧ μ (s n) < ⊤ ∧ ∀ x ∈ s n, f x ≤ ↑n) ∧ ⋃ i, s i = Set.univ

full_name: tendsto_measure_Icc_nhdsWithin_right'
code: lemma tendsto_measure_Icc_nhdsWithin_right' (b : ℝ) :
    Tendsto (fun δ ↦ μ (Icc (b - δ) (b + δ))) (𝓝[>] (0 : ℝ)) (𝓝 (μ {b})) 
goal: Filter.Tendsto (fun δ => μ (Set.Icc (b - δ) (b + δ))) (𝓝[>] 0) (𝓝 (μ {b}))

full_name: tendsto_measure_Icc_nhdsWithin_right
code: lemma tendsto_measure_Icc_nhdsWithin_right (b : ℝ) :
    Tendsto (fun δ ↦ μ (Icc (b - δ) (b + δ))) (𝓝[≥] (0 : ℝ)) (𝓝 (μ {b})) 
goal: Filter.Tendsto (fun δ => μ (Set.Icc (b - δ) (b + δ))) (𝓝[≥] 0) (𝓝 (μ {b}))

full_name: tendsto_measure_Icc
code: lemma tendsto_measure_Icc [NoAtoms μ] (b : ℝ) :
    Tendsto (fun δ ↦ μ (Icc (b - δ) (b + δ))) (𝓝 (0 : ℝ)) (𝓝 0) 
goal: Filter.Tendsto (fun δ => μ (Set.Icc (b - δ) (b + δ))) (𝓝 0) (𝓝 0)