File: Mathlib/MeasureTheory/Measure/WithDensityFinite.lean

full_name: MeasureTheory.Measure.toFiniteAux
code: /-- Auxiliary definition for `MeasureTheory.Measure.toFinite`. -/
noncomputable def Measure.toFiniteAux (μ : Measure α) [SFinite μ] : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.Measure.toFinite
code: /-- A finite measure obtained from an s-finite measure `μ`, such that
`μ = μ.toFinite.withDensity μ.densityToFinite` (see `withDensity_densitytoFinite`).
If `μ` is non-zero, this is a probability measure. -/
noncomputable def Measure.toFinite (μ : Measure α) [SFinite μ] : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.toFiniteAux_apply
code: lemma toFiniteAux_apply (μ : Measure α) [SFinite μ] (s : Set α) :
    μ.toFiniteAux s = ∑' n, (2 ^ (n + 1) * sFiniteSeq μ n Set.univ)⁻¹ * sFiniteSeq μ n s 
goal: μ.toFiniteAux s =
  ∑' (n : ℕ), (2 ^ (n + 1) * (MeasureTheory.sFiniteSeq μ n) Set.univ)⁻¹ * (MeasureTheory.sFiniteSeq μ n) s

full_name: MeasureTheory.toFinite_apply
code: lemma toFinite_apply (μ : Measure α) [SFinite μ] (s : Set α) :
    μ.toFinite s = (μ.toFiniteAux Set.univ)⁻¹ * μ.toFiniteAux s 
goal: μ.toFinite s = (μ.toFiniteAux Set.univ)⁻¹ * μ.toFiniteAux s

full_name: MeasureTheory.toFiniteAux_zero
code: lemma toFiniteAux_zero : Measure.toFiniteAux (0 : Measure α) = 0 
goal: MeasureTheory.Measure.toFiniteAux 0 = 0

full_name: MeasureTheory.toFinite_zero
code: @[simp]
lemma toFinite_zero : Measure.toFinite (0 : Measure α) = 0 
goal: MeasureTheory.Measure.toFinite 0 = 0

full_name: MeasureTheory.toFiniteAux_eq_zero_iff
code: lemma toFiniteAux_eq_zero_iff [SFinite μ] : μ.toFiniteAux = 0 ↔ μ = 0 
goal: μ.toFiniteAux = 0 ↔ μ = 0

full_name: MeasureTheory.toFiniteAux_univ_le_one
code: lemma toFiniteAux_univ_le_one (μ : Measure α) [SFinite μ] : μ.toFiniteAux Set.univ ≤ 1 
goal: μ.toFiniteAux Set.univ ≤ 1

full_name: MeasureTheory.instIsFiniteMeasureToFiniteAux
code: instance [SFinite μ] : IsFiniteMeasure μ.toFiniteAux 
goal: MeasureTheory.IsFiniteMeasure μ.toFiniteAux

full_name: MeasureTheory.toFinite_eq_zero_iff
code: @[simp]
lemma toFinite_eq_zero_iff [SFinite μ] : μ.toFinite = 0 ↔ μ = 0 
goal: μ.toFinite = 0 ↔ μ = 0

full_name: MeasureTheory.instIsFiniteMeasureToFinite
code: instance [SFinite μ] : IsFiniteMeasure μ.toFinite 
goal: MeasureTheory.IsFiniteMeasure μ.toFinite

full_name: MeasureTheory.instIsProbabilityMeasureToFiniteOfNeZeroMeasure
code: instance [SFinite μ] [h_zero : NeZero μ] : IsProbabilityMeasure μ.toFinite 
goal: MeasureTheory.IsProbabilityMeasure μ.toFinite

full_name: MeasureTheory.sFiniteSeq_absolutelyContinuous_toFiniteAux
code: lemma sFiniteSeq_absolutelyContinuous_toFiniteAux (μ : Measure α) [SFinite μ] (n : ℕ) :
    sFiniteSeq μ n ≪ μ.toFiniteAux 
goal: (MeasureTheory.sFiniteSeq μ n).AbsolutelyContinuous μ.toFiniteAux

full_name: MeasureTheory.toFiniteAux_absolutelyContinuous_toFinite
code: lemma toFiniteAux_absolutelyContinuous_toFinite (μ : Measure α) [SFinite μ] :
    μ.toFiniteAux ≪ μ.toFinite 
goal: μ.toFiniteAux.AbsolutelyContinuous μ.toFinite

full_name: MeasureTheory.sFiniteSeq_absolutelyContinuous_toFinite
code: lemma sFiniteSeq_absolutelyContinuous_toFinite (μ : Measure α) [SFinite μ] (n : ℕ) :
    sFiniteSeq μ n ≪ μ.toFinite 
goal: (MeasureTheory.sFiniteSeq μ n).AbsolutelyContinuous μ.toFinite

full_name: MeasureTheory.absolutelyContinuous_toFinite
code: lemma absolutelyContinuous_toFinite (μ : Measure α) [SFinite μ] : μ ≪ μ.toFinite 
goal: μ.AbsolutelyContinuous μ.toFinite

full_name: MeasureTheory.toFinite_absolutelyContinuous
code: lemma toFinite_absolutelyContinuous (μ : Measure α) [SFinite μ] : μ.toFinite ≪ μ 
goal: μ.toFinite.AbsolutelyContinuous μ

full_name: MeasureTheory.Measure.densityToFinite
code: /-- A measurable function such that `μ.toFinite.withDensity μ.densityToFinite = μ`.
See `withDensity_densitytoFinite`. -/
noncomputable
def Measure.densityToFinite (μ : Measure α) [SFinite μ] (a : α) : ℝ≥0∞ 
goal: ℝ≥0∞

full_name: MeasureTheory.densityToFinite_def
code: lemma densityToFinite_def (μ : Measure α) [SFinite μ] :
    μ.densityToFinite = fun a ↦ ∑' n, (sFiniteSeq μ n).rnDeriv μ.toFinite a 
goal: μ.densityToFinite = fun a => ∑' (n : ℕ), (MeasureTheory.sFiniteSeq μ n).rnDeriv μ.toFinite a

full_name: MeasureTheory.measurable_densityToFinite
code: lemma measurable_densityToFinite (μ : Measure α) [SFinite μ] : Measurable μ.densityToFinite 
goal: Measurable μ.densityToFinite

full_name: MeasureTheory.withDensity_densitytoFinite
code: theorem withDensity_densitytoFinite (μ : Measure α) [SFinite μ] :
    μ.toFinite.withDensity μ.densityToFinite = μ 
goal: μ.toFinite.withDensity μ.densityToFinite = μ

full_name: MeasureTheory.densityToFinite_ae_lt_top
code: lemma densityToFinite_ae_lt_top (μ : Measure α) [SigmaFinite μ] :
    ∀ᵐ x ∂μ, μ.densityToFinite x < ∞ 
goal: ∀ᵐ (x : α) ∂μ, μ.densityToFinite x < ⊤

full_name: MeasureTheory.densityToFinite_ae_ne_top
code: lemma densityToFinite_ae_ne_top (μ : Measure α) [SigmaFinite μ] :
    ∀ᵐ x ∂μ, μ.densityToFinite x ≠ ∞ 
goal: ∀ᵐ (x : α) ∂μ, μ.densityToFinite x ≠ ⊤

full_name: MeasureTheory.Measure.sigmaFiniteSet
code: /-- A measurable set such that `μ.restrict μ.sigmaFiniteSet` is sigma-finite,
  and for all measurable sets `s ⊆ μ.sigmaFiniteSetᶜ`, either `μ s = 0` or `μ s = ∞`. -/
def Measure.sigmaFiniteSet (μ : Measure α) [SFinite μ] : Set α 
goal: Set α

full_name: MeasureTheory.measurableSet_sigmaFiniteSet
code: lemma measurableSet_sigmaFiniteSet (μ : Measure α) [SFinite μ] :
    MeasurableSet μ.sigmaFiniteSet 
goal: MeasurableSet μ.sigmaFiniteSet

full_name: MeasureTheory.restrict_compl_sigmaFiniteSet
code: lemma restrict_compl_sigmaFiniteSet [SFinite μ] :
    μ.restrict μ.sigmaFiniteSetᶜ = ∞ • μ.toFinite.restrict μ.sigmaFiniteSetᶜ 
goal: μ.restrict μ.sigmaFiniteSetᶜ = ⊤ • μ.toFinite.restrict μ.sigmaFiniteSetᶜ

full_name: MeasureTheory.restrict_compl_sigmaFiniteSet_eq_zero_or_top
code: /-- The measure `μ.restrict μ.sigmaFiniteSetᶜ` takes only two values: 0 and ∞ . -/
lemma restrict_compl_sigmaFiniteSet_eq_zero_or_top (μ : Measure α) [SFinite μ] (s : Set α) :
    μ.restrict μ.sigmaFiniteSetᶜ s = 0 ∨ μ.restrict μ.sigmaFiniteSetᶜ s = ∞ 
goal: (μ.restrict μ.sigmaFiniteSetᶜ) s = 0 ∨ (μ.restrict μ.sigmaFiniteSetᶜ) s = ⊤

full_name: MeasureTheory.measure_eq_zero_or_top_of_subset_compl_sigmaFiniteSet
code: lemma measure_eq_zero_or_top_of_subset_compl_sigmaFiniteSet [SFinite μ]
    (ht_subset : t ⊆ μ.sigmaFiniteSetᶜ) :
    μ t = 0 ∨ μ t = ∞ 
goal: μ t = 0 ∨ μ t = ⊤

full_name: MeasureTheory.toFinite_withDensity_restrict_sigmaFiniteSet
code: lemma toFinite_withDensity_restrict_sigmaFiniteSet (μ : Measure α) [SFinite μ] :
    (μ.toFinite.withDensity
        (fun x ↦ if μ.densityToFinite x ≠ ∞ then μ.densityToFinite x else 1)).restrict
        μ.sigmaFiniteSet
      = μ.restrict μ.sigmaFiniteSet 
goal: (μ.toFinite.withDensity fun x => if μ.densityToFinite x ≠ ⊤ then μ.densityToFinite x else 1).restrict μ.sigmaFiniteSet =
  μ.restrict μ.sigmaFiniteSet

full_name: MeasureTheory.instSigmaFiniteRestrictSigmaFiniteSet
code: /-- The restriction of an s-finite measure `μ` to `μ.sigmaFiniteSet` is sigma-finite. -/
instance (μ : Measure α) [SFinite μ] : SigmaFinite (μ.restrict μ.sigmaFiniteSet) 
goal: MeasureTheory.SigmaFinite (μ.restrict μ.sigmaFiniteSet)

full_name: MeasureTheory.sigmaFinite_of_measure_compl_sigmaFiniteSet_eq_zero
code: lemma sigmaFinite_of_measure_compl_sigmaFiniteSet_eq_zero [SFinite μ]
    (h : μ μ.sigmaFiniteSetᶜ = 0) :
    SigmaFinite μ 
goal: MeasureTheory.SigmaFinite μ

full_name: MeasureTheory.measure_compl_sigmaFiniteSet
code: @[simp]
lemma measure_compl_sigmaFiniteSet (μ : Measure α) [SigmaFinite μ] : μ μ.sigmaFiniteSetᶜ = 0 
goal: μ μ.sigmaFiniteSetᶜ = 0

full_name: MeasureTheory.measure_compl_sigmaFiniteSet_eq_zero_iff_sigmaFinite
code: /-- An s-finite measure `μ` is sigma-finite iff `μ μ.sigmaFiniteSetᶜ = 0`. -/
lemma measure_compl_sigmaFiniteSet_eq_zero_iff_sigmaFinite (μ : Measure α) [SFinite μ] :
    μ μ.sigmaFiniteSetᶜ = 0 ↔ SigmaFinite μ 
goal: μ μ.sigmaFiniteSetᶜ = 0 ↔ MeasureTheory.SigmaFinite μ