File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

full_name: MeasureTheory.Measure.HaveLebesgueDecomposition
code: /-- A pair of measures `μ` and `ν` is said to `HaveLebesgueDecomposition` if there exists a
measure `ξ` and a measurable function `f`, such that `ξ` is mutually singular with respect to
`ν` and `μ = ξ + ν.withDensity f`. -/
class HaveLebesgueDecomposition (μ ν : Measure α) : Prop where
  lebesgue_decomposition :
    ∃ p : Measure α × (α → ℝ≥0∞), Measurable p.2 ∧ p.1 ⟂ₘ ν ∧ μ = p.1 + ν.withDensity p.2
goal: Prop

full_name: MeasureTheory.Measure.HaveLebesgueDecomposition.lebesgue_decomposition
code: /-- A pair of measures `μ` and `ν` is said to `HaveLebesgueDecomposition` if there exists a
measure `ξ` and a measurable function `f`, such that `ξ` is mutually singular with respect to
`ν` and `μ = ξ + ν.withDensity f`. -/
class HaveLebesgueDecomposition (μ ν : Measure α) : Prop where
  lebesgue_decomposition :
    ∃ p : Measure α × (α → ℝ≥0∞), Measurable p.2 ∧ p.1 ⟂ₘ ν ∧ μ = p.1 + ν.withDensity p.2
goal: ∃ p, Measurable p.2 ∧ p.1 ⟂ₘ ν ∧ μ = p.1 + ν.withDensity p.2

full_name: MeasureTheory.Measure.singularPart
code: /-- If a pair of measures `HaveLebesgueDecomposition`, then `singularPart` chooses the
measure from `HaveLebesgueDecomposition`, otherwise it returns the zero measure. For sigma-finite
measures, `μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)`. -/
noncomputable irreducible_def singularPart (μ ν : Measure α) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.Measure.definition._@.Mathlib.MeasureTheory.Decomposition.Lebesgue._hyg.89
code: /-- If a pair of measures `HaveLebesgueDecomposition`, then `singularPart` chooses the
measure from `HaveLebesgueDecomposition`, otherwise it returns the zero measure. For sigma-finite
measures, `μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)`. -/
noncomputable irreducible_def singularPart (μ ν : Measure α) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.Measure.singularPart_def
code: /-- If a pair of measures `HaveLebesgueDecomposition`, then `singularPart` chooses the
measure from `HaveLebesgueDecomposition`, otherwise it returns the zero measure. For sigma-finite
measures, `μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)`. -/
noncomputable irreducible_def singularPart (μ ν : Measure α) : Measure α 
goal: μ.singularPart ν = if h : μ.HaveLebesgueDecomposition ν then (Classical.choose ⋯).1 else 0

full_name: MeasureTheory.Measure.wrapped._@.Mathlib.MeasureTheory.Decomposition.Lebesgue._hyg.89
code: /-- If a pair of measures `HaveLebesgueDecomposition`, then `singularPart` chooses the
measure from `HaveLebesgueDecomposition`, otherwise it returns the zero measure. For sigma-finite
measures, `μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)`. -/
noncomputable irreducible_def singularPart (μ ν : Measure α) : Measure α 
goal: Subtype (Eq @MeasureTheory.Measure.definition✝)

full_name: MeasureTheory.Measure.wrapped._@.Mathlib.MeasureTheory.Decomposition.Lebesgue._hyg.267
code: /-- If a pair of measures `HaveLebesgueDecomposition`, then `rnDeriv` chooses the
measurable function from `HaveLebesgueDecomposition`, otherwise it returns the zero function.
For sigma-finite measures, `μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)`. -/
noncomputable irreducible_def rnDeriv (μ ν : Measure α) : α → ℝ≥0∞ 
goal: Subtype (Eq @MeasureTheory.Measure.definition✝)

full_name: MeasureTheory.Measure.rnDeriv
code: /-- If a pair of measures `HaveLebesgueDecomposition`, then `rnDeriv` chooses the
measurable function from `HaveLebesgueDecomposition`, otherwise it returns the zero function.
For sigma-finite measures, `μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)`. -/
noncomputable irreducible_def rnDeriv (μ ν : Measure α) : α → ℝ≥0∞ 
goal: α → ℝ≥0∞

full_name: MeasureTheory.Measure.rnDeriv_def
code: /-- If a pair of measures `HaveLebesgueDecomposition`, then `rnDeriv` chooses the
measurable function from `HaveLebesgueDecomposition`, otherwise it returns the zero function.
For sigma-finite measures, `μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)`. -/
noncomputable irreducible_def rnDeriv (μ ν : Measure α) : α → ℝ≥0∞ 
goal: μ.rnDeriv ν = if h : μ.HaveLebesgueDecomposition ν then (Classical.choose ⋯).2 else 0

full_name: MeasureTheory.Measure.definition._@.Mathlib.MeasureTheory.Decomposition.Lebesgue._hyg.267
code: /-- If a pair of measures `HaveLebesgueDecomposition`, then `rnDeriv` chooses the
measurable function from `HaveLebesgueDecomposition`, otherwise it returns the zero function.
For sigma-finite measures, `μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)`. -/
noncomputable irreducible_def rnDeriv (μ ν : Measure α) : α → ℝ≥0∞ 
goal: α → ℝ≥0∞

full_name: MeasureTheory.Measure.haveLebesgueDecomposition_spec
code: theorem haveLebesgueDecomposition_spec (μ ν : Measure α) [h : HaveLebesgueDecomposition μ ν] :
    Measurable (μ.rnDeriv ν) ∧
      μ.singularPart ν ⟂ₘ ν ∧ μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν) 
goal: Measurable (μ.rnDeriv ν) ∧ μ.singularPart ν ⟂ₘ ν ∧ μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)

full_name: MeasureTheory.Measure.rnDeriv_of_not_haveLebesgueDecomposition
code: lemma rnDeriv_of_not_haveLebesgueDecomposition (h : ¬ HaveLebesgueDecomposition μ ν) :
    μ.rnDeriv ν = 0 
goal: μ.rnDeriv ν = 0

full_name: MeasureTheory.Measure.singularPart_of_not_haveLebesgueDecomposition
code: lemma singularPart_of_not_haveLebesgueDecomposition (h : ¬ HaveLebesgueDecomposition μ ν) :
    μ.singularPart ν = 0 
goal: μ.singularPart ν = 0

full_name: MeasureTheory.Measure.measurable_rnDeriv
code: @[measurability, fun_prop]
theorem measurable_rnDeriv (μ ν : Measure α) : Measurable <| μ.rnDeriv ν 
goal: Measurable (μ.rnDeriv ν)

full_name: MeasureTheory.Measure.mutuallySingular_singularPart
code: theorem mutuallySingular_singularPart (μ ν : Measure α) : μ.singularPart ν ⟂ₘ ν 
goal: μ.singularPart ν ⟂ₘ ν

full_name: MeasureTheory.Measure.haveLebesgueDecomposition_add
code: theorem haveLebesgueDecomposition_add (μ ν : Measure α) [HaveLebesgueDecomposition μ ν] :
    μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν) 
goal: μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)

full_name: MeasureTheory.Measure.singularPart_add_rnDeriv
code: lemma singularPart_add_rnDeriv (μ ν : Measure α) [HaveLebesgueDecomposition μ ν] :
    μ.singularPart ν + ν.withDensity (μ.rnDeriv ν) = μ 
goal: μ.singularPart ν + ν.withDensity (μ.rnDeriv ν) = μ

full_name: MeasureTheory.Measure.rnDeriv_add_singularPart
code: lemma rnDeriv_add_singularPart (μ ν : Measure α) [HaveLebesgueDecomposition μ ν] :
    ν.withDensity (μ.rnDeriv ν) + μ.singularPart ν = μ 
goal: ν.withDensity (μ.rnDeriv ν) + μ.singularPart ν = μ

full_name: MeasureTheory.Measure.instHaveLebesgueDecompositionZeroLeft
code: instance instHaveLebesgueDecompositionZeroLeft : HaveLebesgueDecomposition 0 ν 
goal: MeasureTheory.Measure.HaveLebesgueDecomposition 0 ν

full_name: MeasureTheory.Measure.instHaveLebesgueDecompositionZeroRight
code: instance instHaveLebesgueDecompositionZeroRight : HaveLebesgueDecomposition μ 0 
goal: μ.HaveLebesgueDecomposition 0

full_name: MeasureTheory.Measure.instHaveLebesgueDecompositionSelf
code: instance instHaveLebesgueDecompositionSelf : HaveLebesgueDecomposition μ μ 
goal: μ.HaveLebesgueDecomposition μ

full_name: MeasureTheory.Measure.HaveLebesgueDecomposition.sum_left
code: instance HaveLebesgueDecomposition.sum_left {ι : Type*} [Countable ι] (μ : ι → Measure α)
    [∀ i, HaveLebesgueDecomposition (μ i) ν] : HaveLebesgueDecomposition (.sum μ) ν 
goal: (MeasureTheory.Measure.sum μ).HaveLebesgueDecomposition ν

full_name: MeasureTheory.Measure.HaveLebesgueDecomposition.add_left
code: instance HaveLebesgueDecomposition.add_left {μ' : Measure α} [HaveLebesgueDecomposition μ ν]
    [HaveLebesgueDecomposition μ' ν] : HaveLebesgueDecomposition (μ + μ') ν 
goal: (μ + μ').HaveLebesgueDecomposition ν

full_name: MeasureTheory.Measure.haveLebesgueDecompositionSMul'
code: instance haveLebesgueDecompositionSMul' (μ ν : Measure α) [HaveLebesgueDecomposition μ ν]
    (r : ℝ≥0∞) : (r • μ).HaveLebesgueDecomposition ν 
goal: (r • μ).HaveLebesgueDecomposition ν

full_name: MeasureTheory.Measure.haveLebesgueDecompositionSMul
code: instance haveLebesgueDecompositionSMul (μ ν : Measure α) [HaveLebesgueDecomposition μ ν]
    (r : ℝ≥0) : (r • μ).HaveLebesgueDecomposition ν 
goal: (r • μ).HaveLebesgueDecomposition ν

full_name: MeasureTheory.Measure.haveLebesgueDecompositionSMulRight
code: instance haveLebesgueDecompositionSMulRight (μ ν : Measure α) [HaveLebesgueDecomposition μ ν]
    (r : ℝ≥0) :
    μ.HaveLebesgueDecomposition (r • ν) 
goal: μ.HaveLebesgueDecomposition (r • ν)

full_name: MeasureTheory.Measure.haveLebesgueDecomposition_withDensity
code: theorem haveLebesgueDecomposition_withDensity (μ : Measure α) {f : α → ℝ≥0∞} (hf : Measurable f) :
    (μ.withDensity f).HaveLebesgueDecomposition μ 
goal: (μ.withDensity f).HaveLebesgueDecomposition μ

full_name: MeasureTheory.Measure.haveLebesgueDecompositionRnDeriv
code: instance haveLebesgueDecompositionRnDeriv (μ ν : Measure α) :
    HaveLebesgueDecomposition (ν.withDensity (μ.rnDeriv ν)) ν 
goal: (ν.withDensity (μ.rnDeriv ν)).HaveLebesgueDecomposition ν

full_name: MeasureTheory.Measure.instHaveLebesgueDecompositionSingularPart
code: instance instHaveLebesgueDecompositionSingularPart :
    HaveLebesgueDecomposition (μ.singularPart ν) ν 
goal: (μ.singularPart ν).HaveLebesgueDecomposition ν

full_name: MeasureTheory.Measure.singularPart_le
code: theorem singularPart_le (μ ν : Measure α) : μ.singularPart ν ≤ μ 
goal: μ.singularPart ν ≤ μ

full_name: MeasureTheory.Measure.withDensity_rnDeriv_le
code: theorem withDensity_rnDeriv_le (μ ν : Measure α) : ν.withDensity (μ.rnDeriv ν) ≤ μ 
goal: ν.withDensity (μ.rnDeriv ν) ≤ μ

full_name: AEMeasurable.singularPart
code: lemma _root_.AEMeasurable.singularPart {β : Type*} {_ : MeasurableSpace β} {f : α → β}
    (hf : AEMeasurable f μ) (ν : Measure α) :
    AEMeasurable f (μ.singularPart ν) 
goal: ∀ {x : MeasurableSpace β} {f : α → β},
  AEMeasurable f μ → ∀ (ν : MeasureTheory.Measure α), AEMeasurable f (μ.singularPart ν)

full_name: AEMeasurable.withDensity_rnDeriv
code: lemma _root_.AEMeasurable.withDensity_rnDeriv {β : Type*} {_ : MeasurableSpace β} {f : α → β}
    (hf : AEMeasurable f μ) (ν : Measure α) :
    AEMeasurable f (ν.withDensity (μ.rnDeriv ν)) 
goal: ∀ {x : MeasurableSpace β} {f : α → β},
  AEMeasurable f μ → ∀ (ν : MeasureTheory.Measure α), AEMeasurable f (ν.withDensity (μ.rnDeriv ν))

full_name: MeasureTheory.Measure.MutuallySingular.singularPart
code: lemma MutuallySingular.singularPart (h : μ ⟂ₘ ν) (ν' : Measure α) :
    μ.singularPart ν' ⟂ₘ ν 
goal: μ.singularPart ν' ⟂ₘ ν

full_name: MeasureTheory.Measure.absolutelyContinuous_withDensity_rnDeriv
code: lemma absolutelyContinuous_withDensity_rnDeriv [HaveLebesgueDecomposition ν μ] (hμν : μ ≪ ν) :
    μ ≪ μ.withDensity (ν.rnDeriv μ) 
goal: μ ≪ μ.withDensity (ν.rnDeriv μ)

full_name: MeasureTheory.Measure.singularPart_eq_zero_of_ac
code: lemma singularPart_eq_zero_of_ac (h : μ ≪ ν) : μ.singularPart ν = 0 
goal: μ.singularPart ν = 0

full_name: MeasureTheory.Measure.singularPart_zero
code: @[simp]
theorem singularPart_zero (ν : Measure α) : (0 : Measure α).singularPart ν = 0 
goal: MeasureTheory.Measure.singularPart 0 ν = 0

full_name: MeasureTheory.Measure.singularPart_zero_right
code: @[simp]
lemma singularPart_zero_right (μ : Measure α) : μ.singularPart 0 = μ 
goal: μ.singularPart 0 = μ

full_name: MeasureTheory.Measure.singularPart_eq_zero
code: lemma singularPart_eq_zero (μ ν : Measure α) [μ.HaveLebesgueDecomposition ν] :
    μ.singularPart ν = 0 ↔ μ ≪ ν 
goal: μ.singularPart ν = 0 ↔ μ ≪ ν

full_name: MeasureTheory.Measure.withDensity_rnDeriv_eq_zero
code: @[simp]
lemma withDensity_rnDeriv_eq_zero (μ ν : Measure α) [μ.HaveLebesgueDecomposition ν] :
    ν.withDensity (μ.rnDeriv ν) = 0 ↔ μ ⟂ₘ ν 
goal: ν.withDensity (μ.rnDeriv ν) = 0 ↔ μ ⟂ₘ ν

full_name: MeasureTheory.Measure.rnDeriv_eq_zero
code: @[simp]
lemma rnDeriv_eq_zero (μ ν : Measure α) [μ.HaveLebesgueDecomposition ν] :
    μ.rnDeriv ν =ᵐ[ν] 0 ↔ μ ⟂ₘ ν 
goal: μ.rnDeriv ν =ᵐ[ν] 0 ↔ μ ⟂ₘ ν

full_name: MeasureTheory.Measure.rnDeriv_zero
code: lemma rnDeriv_zero (ν : Measure α) : (0 : Measure α).rnDeriv ν =ᵐ[ν] 0 
goal: MeasureTheory.Measure.rnDeriv 0 ν =ᵐ[ν] 0

full_name: MeasureTheory.Measure.MutuallySingular.rnDeriv_ae_eq_zero
code: lemma MutuallySingular.rnDeriv_ae_eq_zero (hμν : μ ⟂ₘ ν) :
    μ.rnDeriv ν =ᵐ[ν] 0 
goal: μ.rnDeriv ν =ᵐ[ν] 0

full_name: MeasureTheory.Measure.singularPart_withDensity
code: @[simp]
theorem singularPart_withDensity (ν : Measure α) (f : α → ℝ≥0∞) :
    (ν.withDensity f).singularPart ν = 0 
goal: (ν.withDensity f).singularPart ν = 0

full_name: MeasureTheory.Measure.rnDeriv_singularPart
code: lemma rnDeriv_singularPart (μ ν : Measure α) :
    (μ.singularPart ν).rnDeriv ν =ᵐ[ν] 0 
goal: (μ.singularPart ν).rnDeriv ν =ᵐ[ν] 0

full_name: MeasureTheory.Measure.singularPart_self
code: @[simp]
lemma singularPart_self (μ : Measure α) : μ.singularPart μ = 0 
goal: μ.singularPart μ = 0

full_name: MeasureTheory.Measure.rnDeriv_self
code: lemma rnDeriv_self (μ : Measure α) [SigmaFinite μ] : μ.rnDeriv μ =ᵐ[μ] fun _ ↦ 1 
goal: μ.rnDeriv μ =ᵐ[μ] fun x => 1

full_name: MeasureTheory.Measure.singularPart_eq_self
code: lemma singularPart_eq_self [μ.HaveLebesgueDecomposition ν] : μ.singularPart ν = μ ↔ μ ⟂ₘ ν 
goal: μ.singularPart ν = μ ↔ μ ⟂ₘ ν

full_name: MeasureTheory.Measure.singularPart_singularPart
code: @[simp]
lemma singularPart_singularPart (μ ν : Measure α) :
    (μ.singularPart ν).singularPart ν = μ.singularPart ν 
goal: (μ.singularPart ν).singularPart ν = μ.singularPart ν

full_name: MeasureTheory.Measure.singularPart.instIsFiniteMeasure
code: instance singularPart.instIsFiniteMeasure [IsFiniteMeasure μ] :
    IsFiniteMeasure (μ.singularPart ν) 
goal: MeasureTheory.IsFiniteMeasure (μ.singularPart ν)

full_name: MeasureTheory.Measure.singularPart.instSigmaFinite
code: instance singularPart.instSigmaFinite [SigmaFinite μ] : SigmaFinite (μ.singularPart ν) 
goal: MeasureTheory.SigmaFinite (μ.singularPart ν)

full_name: MeasureTheory.Measure.singularPart.instIsLocallyFiniteMeasure
code: instance singularPart.instIsLocallyFiniteMeasure [TopologicalSpace α] [IsLocallyFiniteMeasure μ] :
    IsLocallyFiniteMeasure (μ.singularPart ν) 
goal: MeasureTheory.IsLocallyFiniteMeasure (μ.singularPart ν)

full_name: MeasureTheory.Measure.withDensity.instIsFiniteMeasure
code: instance withDensity.instIsFiniteMeasure [IsFiniteMeasure μ] :
    IsFiniteMeasure (ν.withDensity <| μ.rnDeriv ν) 
goal: MeasureTheory.IsFiniteMeasure (ν.withDensity (μ.rnDeriv ν))

full_name: MeasureTheory.Measure.withDensity.instSigmaFinite
code: instance withDensity.instSigmaFinite [SigmaFinite μ] :
    SigmaFinite (ν.withDensity <| μ.rnDeriv ν) 
goal: MeasureTheory.SigmaFinite (ν.withDensity (μ.rnDeriv ν))

full_name: MeasureTheory.Measure.withDensity.instIsLocallyFiniteMeasure
code: instance withDensity.instIsLocallyFiniteMeasure [TopologicalSpace α] [IsLocallyFiniteMeasure μ] :
    IsLocallyFiniteMeasure (ν.withDensity <| μ.rnDeriv ν) 
goal: MeasureTheory.IsLocallyFiniteMeasure (ν.withDensity (μ.rnDeriv ν))

full_name: MeasureTheory.Measure.lintegral_rnDeriv_lt_top_of_measure_ne_top
code: theorem lintegral_rnDeriv_lt_top_of_measure_ne_top (ν : Measure α) {s : Set α} (hs : μ s ≠ ∞) :
    ∫⁻ x in s, μ.rnDeriv ν x ∂ν < ∞ 
goal: ∫⁻ (x : α) in s, μ.rnDeriv ν x ∂ν < ⊤

full_name: MeasureTheory.Measure.lintegral_rnDeriv_lt_top
code: theorem lintegral_rnDeriv_lt_top (μ ν : Measure α) [IsFiniteMeasure μ] :
    ∫⁻ x, μ.rnDeriv ν x ∂ν < ∞ 
goal: ∫⁻ (x : α), μ.rnDeriv ν x ∂ν < ⊤

full_name: MeasureTheory.Measure.integrable_toReal_rnDeriv
code: lemma integrable_toReal_rnDeriv [IsFiniteMeasure μ] :
    Integrable (fun x ↦ (μ.rnDeriv ν x).toReal) ν 
goal: MeasureTheory.Integrable (fun x => (μ.rnDeriv ν x).toReal) ν

full_name: MeasureTheory.Measure.rnDeriv_lt_top
code: /-- The Radon-Nikodym derivative of a sigma-finite measure `μ` with respect to another
measure `ν` is `ν`-almost everywhere finite. -/
theorem rnDeriv_lt_top (μ ν : Measure α) [SigmaFinite μ] : ∀ᵐ x ∂ν, μ.rnDeriv ν x < ∞ 
goal: ∀ᵐ (x : α) ∂ν, μ.rnDeriv ν x < ⊤

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

full_name: MeasureTheory.Measure.eq_singularPart
code: /-- Given measures `μ` and `ν`, if `s` is a measure mutually singular to `ν` and `f` is a
measurable function such that `μ = s + fν`, then `s = μ.singularPart μ`.

This theorem provides the uniqueness of the `singularPart` in the Lebesgue decomposition theorem,
while `MeasureTheory.Measure.eq_rnDeriv` provides the uniqueness of the
`rnDeriv`. -/
theorem eq_singularPart {s : Measure α} {f : α → ℝ≥0∞} (hf : Measurable f) (hs : s ⟂ₘ ν)
    (hadd : μ = s + ν.withDensity f) : s = μ.singularPart ν 
goal: s = μ.singularPart ν

full_name: MeasureTheory.Measure.singularPart_smul
code: theorem singularPart_smul (μ ν : Measure α) (r : ℝ≥0) :
    (r • μ).singularPart ν = r • μ.singularPart ν 
goal: (r • μ).singularPart ν = r • μ.singularPart ν

full_name: MeasureTheory.Measure.singularPart_smul_right
code: theorem singularPart_smul_right (μ ν : Measure α) (r : ℝ≥0) (hr : r ≠ 0) :
    μ.singularPart (r • ν) = μ.singularPart ν 
goal: μ.singularPart (r • ν) = μ.singularPart ν

full_name: MeasureTheory.Measure.singularPart_add
code: theorem singularPart_add (μ₁ μ₂ ν : Measure α) [HaveLebesgueDecomposition μ₁ ν]
    [HaveLebesgueDecomposition μ₂ ν] :
    (μ₁ + μ₂).singularPart ν = μ₁.singularPart ν + μ₂.singularPart ν 
goal: (μ₁ + μ₂).singularPart ν = μ₁.singularPart ν + μ₂.singularPart ν

full_name: MeasureTheory.Measure.singularPart_restrict
code: lemma singularPart_restrict (μ ν : Measure α) [HaveLebesgueDecomposition μ ν]
    {s : Set α} (hs : MeasurableSet s) :
    (μ.restrict s).singularPart ν = (μ.singularPart ν).restrict s 
goal: (μ.restrict s).singularPart ν = (μ.singularPart ν).restrict s

full_name: MeasureTheory.Measure.eq_withDensity_rnDeriv
code: /-- Given measures `μ` and `ν`, if `s` is a measure mutually singular to `ν` and `f` is a
measurable function such that `μ = s + fν`, then `f = μ.rnDeriv ν`.

This theorem provides the uniqueness of the `rnDeriv` in the Lebesgue decomposition
theorem, while `MeasureTheory.Measure.eq_singularPart` provides the uniqueness of the
`singularPart`. Here, the uniqueness is given in terms of the measures, while the uniqueness in
terms of the functions is given in `eq_rnDeriv`. -/
theorem eq_withDensity_rnDeriv {s : Measure α} {f : α → ℝ≥0∞} (hf : Measurable f) (hs : s ⟂ₘ ν)
    (hadd : μ = s + ν.withDensity f) : ν.withDensity f = ν.withDensity (μ.rnDeriv ν) 
goal: ν.withDensity f = ν.withDensity (μ.rnDeriv ν)

full_name: MeasureTheory.Measure.eq_withDensity_rnDeriv₀
code: theorem eq_withDensity_rnDeriv₀ {s : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f ν) (hs : s ⟂ₘ ν) (hadd : μ = s + ν.withDensity f) :
    ν.withDensity f = ν.withDensity (μ.rnDeriv ν) 
goal: ν.withDensity f = ν.withDensity (μ.rnDeriv ν)

full_name: MeasureTheory.Measure.eq_rnDeriv₀
code: theorem eq_rnDeriv₀ [SigmaFinite ν] {s : Measure α} {f : α → ℝ≥0∞}
    (hf : AEMeasurable f ν) (hs : s ⟂ₘ ν) (hadd : μ = s + ν.withDensity f) :
    f =ᵐ[ν] μ.rnDeriv ν 
goal: f =ᵐ[ν] μ.rnDeriv ν

full_name: MeasureTheory.Measure.eq_rnDeriv
code: /-- Given measures `μ` and `ν`, if `s` is a measure mutually singular to `ν` and `f` is a
measurable function such that `μ = s + fν`, then `f = μ.rnDeriv ν`.

This theorem provides the uniqueness of the `rnDeriv` in the Lebesgue decomposition
theorem, while `MeasureTheory.Measure.eq_singularPart` provides the uniqueness of the
`singularPart`. Here, the uniqueness is given in terms of the functions, while the uniqueness in
terms of the functions is given in `eq_withDensity_rnDeriv`. -/
theorem eq_rnDeriv [SigmaFinite ν] {s : Measure α} {f : α → ℝ≥0∞} (hf : Measurable f) (hs : s ⟂ₘ ν)
    (hadd : μ = s + ν.withDensity f) : f =ᵐ[ν] μ.rnDeriv ν 
goal: f =ᵐ[ν] μ.rnDeriv ν

full_name: MeasureTheory.Measure.rnDeriv_withDensity₀
code: /-- The Radon-Nikodym derivative of `f ν` with respect to `ν` is `f`. -/
theorem rnDeriv_withDensity₀ (ν : Measure α) [SigmaFinite ν] {f : α → ℝ≥0∞}
    (hf : AEMeasurable f ν) :
    (ν.withDensity f).rnDeriv ν =ᵐ[ν] f 
goal: (ν.withDensity f).rnDeriv ν =ᵐ[ν] f

full_name: MeasureTheory.Measure.rnDeriv_withDensity
code: /-- The Radon-Nikodym derivative of `f ν` with respect to `ν` is `f`. -/
theorem rnDeriv_withDensity (ν : Measure α) [SigmaFinite ν] {f : α → ℝ≥0∞} (hf : Measurable f) :
    (ν.withDensity f).rnDeriv ν =ᵐ[ν] f 
goal: (ν.withDensity f).rnDeriv ν =ᵐ[ν] f

full_name: MeasureTheory.Measure.rnDeriv_restrict
code: lemma rnDeriv_restrict (μ ν : Measure α) [HaveLebesgueDecomposition μ ν] [SigmaFinite ν]
    {s : Set α} (hs : MeasurableSet s) :
    (μ.restrict s).rnDeriv ν =ᵐ[ν] s.indicator (μ.rnDeriv ν) 
goal: (μ.restrict s).rnDeriv ν =ᵐ[ν] s.indicator (μ.rnDeriv ν)

full_name: MeasureTheory.Measure.rnDeriv_restrict_self
code: /-- The Radon-Nikodym derivative of the restriction of a measure to a measurable set is the
indicator function of this set. -/
theorem rnDeriv_restrict_self (ν : Measure α) [SigmaFinite ν] {s : Set α} (hs : MeasurableSet s) :
    (ν.restrict s).rnDeriv ν =ᵐ[ν] s.indicator 1 
goal: (ν.restrict s).rnDeriv ν =ᵐ[ν] s.indicator 1

full_name: MeasureTheory.Measure.rnDeriv_smul_left
code: /-- Radon-Nikodym derivative of the scalar multiple of a measure.
See also `rnDeriv_smul_left'`, which requires sigma-finite `ν` and `μ`. -/
theorem rnDeriv_smul_left (ν μ : Measure α) [IsFiniteMeasure ν]
    [ν.HaveLebesgueDecomposition μ] (r : ℝ≥0) :
    (r • ν).rnDeriv μ =ᵐ[μ] r • ν.rnDeriv μ 
goal: (r • ν).rnDeriv μ =ᵐ[μ] r • ν.rnDeriv μ

full_name: MeasureTheory.Measure.rnDeriv_smul_left_of_ne_top
code: /-- Radon-Nikodym derivative of the scalar multiple of a measure.
See also `rnDeriv_smul_left_of_ne_top'`, which requires sigma-finite `ν` and `μ`. -/
theorem rnDeriv_smul_left_of_ne_top (ν μ : Measure α) [IsFiniteMeasure ν]
    [ν.HaveLebesgueDecomposition μ] {r : ℝ≥0∞} (hr : r ≠ ∞) :
    (r • ν).rnDeriv μ =ᵐ[μ] r • ν.rnDeriv μ 
goal: (r • ν).rnDeriv μ =ᵐ[μ] r • ν.rnDeriv μ

full_name: MeasureTheory.Measure.rnDeriv_smul_right
code: /-- Radon-Nikodym derivative with respect to the scalar multiple of a measure.
See also `rnDeriv_smul_right'`, which requires sigma-finite `ν` and `μ`. -/
theorem rnDeriv_smul_right (ν μ : Measure α) [IsFiniteMeasure ν]
    [ν.HaveLebesgueDecomposition μ] {r : ℝ≥0} (hr : r ≠ 0) :
    ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ 
goal: ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ

full_name: MeasureTheory.Measure.rnDeriv_smul_right_of_ne_top
code: /-- Radon-Nikodym derivative with respect to the scalar multiple of a measure.
See also `rnDeriv_smul_right_of_ne_top'`, which requires sigma-finite `ν` and `μ`. -/
theorem rnDeriv_smul_right_of_ne_top (ν μ : Measure α) [IsFiniteMeasure ν]
    [ν.HaveLebesgueDecomposition μ] {r : ℝ≥0∞} (hr : r ≠ 0) (hr_ne_top : r ≠ ∞) :
    ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ 
goal: ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ

full_name: MeasureTheory.Measure.rnDeriv_add
code: /-- Radon-Nikodym derivative of a sum of two measures.
See also `rnDeriv_add'`, which requires sigma-finite `ν₁`, `ν₂` and `μ`. -/
lemma rnDeriv_add (ν₁ ν₂ μ : Measure α) [IsFiniteMeasure ν₁] [IsFiniteMeasure ν₂]
    [ν₁.HaveLebesgueDecomposition μ] [ν₂.HaveLebesgueDecomposition μ]
    [(ν₁ + ν₂).HaveLebesgueDecomposition μ] :
    (ν₁ + ν₂).rnDeriv μ =ᵐ[μ] ν₁.rnDeriv μ + ν₂.rnDeriv μ 
goal: (ν₁ + ν₂).rnDeriv μ =ᵐ[μ] ν₁.rnDeriv μ + ν₂.rnDeriv μ

full_name: MeasureTheory.Measure.exists_positive_of_not_mutuallySingular
code: /-- If two finite measures `μ` and `ν` are not mutually singular, there exists some `ε > 0` and
a measurable set `E`, such that `ν(E) > 0` and `E` is positive with respect to `μ - εν`.

This lemma is useful for the Lebesgue decomposition theorem. -/
theorem exists_positive_of_not_mutuallySingular (μ ν : Measure α) [IsFiniteMeasure μ]
    [IsFiniteMeasure ν] (h : ¬μ ⟂ₘ ν) :
    ∃ ε : ℝ≥0, 0 < ε ∧
      ∃ E : Set α,
        MeasurableSet E ∧ 0 < ν E ∧ 0 ≤[E] μ.toSignedMeasure - (ε • ν).toSignedMeasure 
goal: ∃ ε,
  0 < ε ∧
    ∃ E,
      MeasurableSet E ∧
        0 < ν E ∧
          MeasureTheory.VectorMeasure.restrict 0 E ≤
            MeasureTheory.VectorMeasure.restrict (μ.toSignedMeasure - (ε • ν).toSignedMeasure) E

full_name: MeasureTheory.Measure.LebesgueDecomposition.measurableLE
code: /-- Given two measures `μ` and `ν`, `measurableLE μ ν` is the set of measurable
functions `f`, such that, for all measurable sets `A`, `∫⁻ x in A, f x ∂μ ≤ ν A`.

This is useful for the Lebesgue decomposition theorem. -/
def measurableLE (μ ν : Measure α) : Set (α → ℝ≥0∞) 
goal: Set (α → ℝ≥0∞)

full_name: MeasureTheory.Measure.LebesgueDecomposition.zero_mem_measurableLE
code: theorem zero_mem_measurableLE : (0 : α → ℝ≥0∞) ∈ measurableLE μ ν 
goal: 0 ∈ MeasureTheory.Measure.LebesgueDecomposition.measurableLE μ ν

full_name: MeasureTheory.Measure.LebesgueDecomposition.sup_mem_measurableLE
code: theorem sup_mem_measurableLE {f g : α → ℝ≥0∞} (hf : f ∈ measurableLE μ ν)
    (hg : g ∈ measurableLE μ ν) : (fun a ↦ f a ⊔ g a) ∈ measurableLE μ ν 
goal: (fun a => f a ⊔ g a) ∈ MeasureTheory.Measure.LebesgueDecomposition.measurableLE μ ν

full_name: MeasureTheory.Measure.LebesgueDecomposition.iSup_succ_eq_sup
code: theorem iSup_succ_eq_sup {α} (f : ℕ → α → ℝ≥0∞) (m : ℕ) (a : α) :
    ⨆ (k : ℕ) (_ : k ≤ m + 1), f k a = f m.succ a ⊔ ⨆ (k : ℕ) (_ : k ≤ m), f k a 
goal: ⨆ k, ⨆ (_ : k ≤ m + 1), f k a = f m.succ a ⊔ ⨆ k, ⨆ (_ : k ≤ m), f k a

full_name: MeasureTheory.Measure.LebesgueDecomposition.iSup_mem_measurableLE
code: theorem iSup_mem_measurableLE (f : ℕ → α → ℝ≥0∞) (hf : ∀ n, f n ∈ measurableLE μ ν) (n : ℕ) :
    (fun x ↦ ⨆ (k) (_ : k ≤ n), f k x) ∈ measurableLE μ ν 
goal: (fun x => ⨆ k, ⨆ (_ : k ≤ n), f k x) ∈ MeasureTheory.Measure.LebesgueDecomposition.measurableLE μ ν

full_name: MeasureTheory.Measure.LebesgueDecomposition.iSup_mem_measurableLE'
code: theorem iSup_mem_measurableLE' (f : ℕ → α → ℝ≥0∞) (hf : ∀ n, f n ∈ measurableLE μ ν) (n : ℕ) :
    (⨆ (k) (_ : k ≤ n), f k) ∈ measurableLE μ ν 
goal: ⨆ k, ⨆ (_ : k ≤ n), f k ∈ MeasureTheory.Measure.LebesgueDecomposition.measurableLE μ ν

full_name: MeasureTheory.Measure.LebesgueDecomposition.iSup_monotone
code: theorem iSup_monotone {α : Type*} (f : ℕ → α → ℝ≥0∞) :
    Monotone fun n x ↦ ⨆ (k) (_ : k ≤ n), f k x 
goal: Monotone fun n x => ⨆ k, ⨆ (_ : k ≤ n), f k x

full_name: MeasureTheory.Measure.LebesgueDecomposition.iSup_monotone'
code: theorem iSup_monotone' {α : Type*} (f : ℕ → α → ℝ≥0∞) (x : α) :
    Monotone fun n ↦ ⨆ (k) (_ : k ≤ n), f k x 
goal: Monotone fun n => ⨆ k, ⨆ (_ : k ≤ n), f k x

full_name: MeasureTheory.Measure.LebesgueDecomposition.iSup_le_le
code: theorem iSup_le_le {α : Type*} (f : ℕ → α → ℝ≥0∞) (n k : ℕ) (hk : k ≤ n) :
    f k ≤ fun x ↦ ⨆ (k) (_ : k ≤ n), f k x 
goal: f k ≤ fun x => ⨆ k, ⨆ (_ : k ≤ n), f k x

full_name: MeasureTheory.Measure.LebesgueDecomposition.measurableLEEval
code: /-- `measurableLEEval μ ν` is the set of `∫⁻ x, f x ∂μ` for all `f ∈ measurableLE μ ν`. -/
def measurableLEEval (μ ν : Measure α) : Set ℝ≥0∞ 
goal: Set ℝ≥0∞

full_name: MeasureTheory.Measure.haveLebesgueDecomposition_of_finiteMeasure
code: /-- Any pair of finite measures `μ` and `ν`, `HaveLebesgueDecomposition`. That is to say,
there exist a measure `ξ` and a measurable function `f`, such that `ξ` is mutually singular
with respect to `ν` and `μ = ξ + ν.withDensity f`.

This is not an instance since this is also shown for the more general σ-finite measures with
`MeasureTheory.Measure.haveLebesgueDecomposition_of_sigmaFinite`. -/
theorem haveLebesgueDecomposition_of_finiteMeasure [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
    HaveLebesgueDecomposition μ ν 
goal: μ.HaveLebesgueDecomposition ν

full_name: MeasureTheory.Measure.HaveLebesgueDecomposition.sfinite_of_isFiniteMeasure
code: /-- If any finite measure has a Lebesgue decomposition with respect to `ν`,
then the same is true for any s-finite measure. -/
theorem HaveLebesgueDecomposition.sfinite_of_isFiniteMeasure [SFinite μ]
    (_h : ∀ (μ : Measure α) [IsFiniteMeasure μ], HaveLebesgueDecomposition μ ν) :
    HaveLebesgueDecomposition μ ν 
goal: μ.HaveLebesgueDecomposition ν

full_name: MeasureTheory.Measure.haveLebesgueDecomposition_of_sigmaFinite
code: /-- **The Lebesgue decomposition theorem**:
Any s-finite measure `μ` has Lebesgue decomposition with respect to any σ-finite measure `ν`.
That is to say, there exist a measure `ξ` and a measurable function `f`,
such that `ξ` is mutually singular with respect to `ν` and `μ = ξ + ν.withDensity f` -/
nonrec instance (priority := 100) haveLebesgueDecomposition_of_sigmaFinite
    [SFinite μ] [SigmaFinite ν] : HaveLebesgueDecomposition μ ν 
goal: μ.HaveLebesgueDecomposition ν

full_name: MeasureTheory.Measure.rnDeriv_smul_left'
code: /-- Radon-Nikodym derivative of the scalar multiple of a measure.
See also `rnDeriv_smul_left`, which has no hypothesis on `μ` but requires finite `ν`. -/
theorem rnDeriv_smul_left' (ν μ : Measure α) [SigmaFinite ν] [SigmaFinite μ] (r : ℝ≥0) :
    (r • ν).rnDeriv μ =ᵐ[μ] r • ν.rnDeriv μ 
goal: (r • ν).rnDeriv μ =ᵐ[μ] r • ν.rnDeriv μ

full_name: MeasureTheory.Measure.rnDeriv_smul_left_of_ne_top'
code: /-- Radon-Nikodym derivative of the scalar multiple of a measure.
See also `rnDeriv_smul_left_of_ne_top`, which has no hypothesis on `μ` but requires finite `ν`. -/
theorem rnDeriv_smul_left_of_ne_top' (ν μ : Measure α) [SigmaFinite ν] [SigmaFinite μ]
    {r : ℝ≥0∞} (hr : r ≠ ∞) :
    (r • ν).rnDeriv μ =ᵐ[μ] r • ν.rnDeriv μ 
goal: (r • ν).rnDeriv μ =ᵐ[μ] r • ν.rnDeriv μ

full_name: MeasureTheory.Measure.rnDeriv_smul_right'
code: /-- Radon-Nikodym derivative with respect to the scalar multiple of a measure.
See also `rnDeriv_smul_right`, which has no hypothesis on `μ` but requires finite `ν`. -/
theorem rnDeriv_smul_right' (ν μ : Measure α) [SigmaFinite ν] [SigmaFinite μ]
    {r : ℝ≥0} (hr : r ≠ 0) :
    ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ 
goal: ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ

full_name: MeasureTheory.Measure.rnDeriv_smul_right_of_ne_top'
code: /-- Radon-Nikodym derivative with respect to the scalar multiple of a measure.
See also `rnDeriv_smul_right_of_ne_top`, which has no hypothesis on `μ` but requires finite `ν`. -/
theorem rnDeriv_smul_right_of_ne_top' (ν μ : Measure α) [SigmaFinite ν] [SigmaFinite μ]
    {r : ℝ≥0∞} (hr : r ≠ 0) (hr_ne_top : r ≠ ∞) :
    ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ 
goal: ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ

full_name: MeasureTheory.Measure.rnDeriv_add'
code: /-- Radon-Nikodym derivative of a sum of two measures.
See also `rnDeriv_add`, which has no hypothesis on `μ` but requires finite `ν₁` and `ν₂`. -/
lemma rnDeriv_add' (ν₁ ν₂ μ : Measure α) [SigmaFinite ν₁] [SigmaFinite ν₂] [SigmaFinite μ] :
    (ν₁ + ν₂).rnDeriv μ =ᵐ[μ] ν₁.rnDeriv μ + ν₂.rnDeriv μ 
goal: (ν₁ + ν₂).rnDeriv μ =ᵐ[μ] ν₁.rnDeriv μ + ν₂.rnDeriv μ

full_name: MeasureTheory.Measure.rnDeriv_add_of_mutuallySingular
code: lemma rnDeriv_add_of_mutuallySingular (ν₁ ν₂ μ : Measure α)
    [SigmaFinite ν₁] [SigmaFinite ν₂] [SigmaFinite μ] (h : ν₂ ⟂ₘ μ) :
    (ν₁ + ν₂).rnDeriv μ =ᵐ[μ] ν₁.rnDeriv μ 
goal: (ν₁ + ν₂).rnDeriv μ =ᵐ[μ] ν₁.rnDeriv μ