File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

full_name: MeasureTheory.SignedMeasure.HaveLebesgueDecomposition.posPart
code: /-- A signed measure `s` is said to `HaveLebesgueDecomposition` with respect to a measure `μ`
if the positive part and the negative part of `s` both `HaveLebesgueDecomposition` with
respect to `μ`. -/
class HaveLebesgueDecomposition (s : SignedMeasure α) (μ : Measure α) : Prop where
  posPart : s.toJordanDecomposition.posPart.HaveLebesgueDecomposition μ
  negPart : s.toJordanDecomposition.negPart.HaveLebesgueDecomposition μ
goal: s.toJordanDecomposition.posPart.HaveLebesgueDecomposition μ

full_name: MeasureTheory.SignedMeasure.HaveLebesgueDecomposition
code: /-- A signed measure `s` is said to `HaveLebesgueDecomposition` with respect to a measure `μ`
if the positive part and the negative part of `s` both `HaveLebesgueDecomposition` with
respect to `μ`. -/
class HaveLebesgueDecomposition (s : SignedMeasure α) (μ : Measure α) : Prop where
  posPart : s.toJordanDecomposition.posPart.HaveLebesgueDecomposition μ
  negPart : s.toJordanDecomposition.negPart.HaveLebesgueDecomposition μ
goal: Prop

full_name: MeasureTheory.SignedMeasure.HaveLebesgueDecomposition.negPart
code: /-- A signed measure `s` is said to `HaveLebesgueDecomposition` with respect to a measure `μ`
if the positive part and the negative part of `s` both `HaveLebesgueDecomposition` with
respect to `μ`. -/
class HaveLebesgueDecomposition (s : SignedMeasure α) (μ : Measure α) : Prop where
  posPart : s.toJordanDecomposition.posPart.HaveLebesgueDecomposition μ
  negPart : s.toJordanDecomposition.negPart.HaveLebesgueDecomposition μ
goal: s.toJordanDecomposition.negPart.HaveLebesgueDecomposition μ

full_name: MeasureTheory.SignedMeasure.not_haveLebesgueDecomposition_iff
code: theorem not_haveLebesgueDecomposition_iff (s : SignedMeasure α) (μ : Measure α) :
    ¬s.HaveLebesgueDecomposition μ ↔
      ¬s.toJordanDecomposition.posPart.HaveLebesgueDecomposition μ ∨
        ¬s.toJordanDecomposition.negPart.HaveLebesgueDecomposition μ 
goal: ¬s.HaveLebesgueDecomposition μ ↔
  ¬s.toJordanDecomposition.posPart.HaveLebesgueDecomposition μ ∨
    ¬s.toJordanDecomposition.negPart.HaveLebesgueDecomposition μ

full_name: MeasureTheory.SignedMeasure.haveLebesgueDecomposition_of_sigmaFinite
code: instance (priority := 100) haveLebesgueDecomposition_of_sigmaFinite (s : SignedMeasure α)
    (μ : Measure α) [SigmaFinite μ] : s.HaveLebesgueDecomposition μ 
goal: s.HaveLebesgueDecomposition μ

full_name: MeasureTheory.SignedMeasure.haveLebesgueDecomposition_neg
code: instance haveLebesgueDecomposition_neg (s : SignedMeasure α) (μ : Measure α)
    [s.HaveLebesgueDecomposition μ] : (-s).HaveLebesgueDecomposition μ 
goal: (-s).HaveLebesgueDecomposition μ

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

full_name: MeasureTheory.SignedMeasure.haveLebesgueDecomposition_smul_real
code: instance haveLebesgueDecomposition_smul_real (s : SignedMeasure α) (μ : Measure α)
    [s.HaveLebesgueDecomposition μ] (r : ℝ) : (r • s).HaveLebesgueDecomposition μ 
goal: (r • s).HaveLebesgueDecomposition μ

full_name: MeasureTheory.SignedMeasure.singularPart
code: /-- Given a signed measure `s` and a measure `μ`, `s.singularPart μ` is the signed measure
such that `s.singularPart μ + μ.withDensityᵥ (s.rnDeriv μ) = s` and
`s.singularPart μ` is mutually singular with respect to `μ`. -/
def singularPart (s : SignedMeasure α) (μ : Measure α) : SignedMeasure α 
goal: MeasureTheory.SignedMeasure α

full_name: MeasureTheory.SignedMeasure.singularPart_mutuallySingular
code: theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ 
goal: s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ s.toJordanDecomposition.negPart.singularPart μ

full_name: MeasureTheory.SignedMeasure.singularPart_totalVariation
code: theorem singularPart_totalVariation (s : SignedMeasure α) (μ : Measure α) :
    (s.singularPart μ).totalVariation =
      s.toJordanDecomposition.posPart.singularPart μ +
        s.toJordanDecomposition.negPart.singularPart μ 
goal: (s.singularPart μ).totalVariation =
  s.toJordanDecomposition.posPart.singularPart μ + s.toJordanDecomposition.negPart.singularPart μ

full_name: MeasureTheory.SignedMeasure.mutuallySingular_singularPart
code: nonrec theorem mutuallySingular_singularPart (s : SignedMeasure α) (μ : Measure α) :
    singularPart s μ ⟂ᵥ μ.toENNRealVectorMeasure 
goal: s.singularPart μ ⟂ᵥ μ.toENNRealVectorMeasure

full_name: MeasureTheory.SignedMeasure.rnDeriv
code: /-- The Radon-Nikodym derivative between a signed measure and a positive measure.

`rnDeriv s μ` satisfies `μ.withDensityᵥ (s.rnDeriv μ) = s`
if and only if `s` is absolutely continuous with respect to `μ` and this fact is known as
`MeasureTheory.SignedMeasure.absolutelyContinuous_iff_withDensity_rnDeriv_eq`
and can be found in `MeasureTheory.Decomposition.RadonNikodym`. -/
def rnDeriv (s : SignedMeasure α) (μ : Measure α) : α → ℝ 
goal: α → ℝ

full_name: MeasureTheory.SignedMeasure.rnDeriv_def
code: theorem rnDeriv_def (s : SignedMeasure α) (μ : Measure α) : rnDeriv s μ = fun x =>
    (s.toJordanDecomposition.posPart.rnDeriv μ x).toReal -
      (s.toJordanDecomposition.negPart.rnDeriv μ x).toReal 
goal: s.rnDeriv μ = fun x =>
  (s.toJordanDecomposition.posPart.rnDeriv μ x).toReal - (s.toJordanDecomposition.negPart.rnDeriv μ x).toReal

full_name: MeasureTheory.SignedMeasure.measurable_rnDeriv
code: @[measurability]
theorem measurable_rnDeriv (s : SignedMeasure α) (μ : Measure α) : Measurable (rnDeriv s μ) 
goal: Measurable (s.rnDeriv μ)

full_name: MeasureTheory.SignedMeasure.integrable_rnDeriv
code: theorem integrable_rnDeriv (s : SignedMeasure α) (μ : Measure α) : Integrable (rnDeriv s μ) μ 
goal: MeasureTheory.Integrable (s.rnDeriv μ) μ

full_name: MeasureTheory.SignedMeasure.singularPart_add_withDensity_rnDeriv_eq
code: /-- **The Lebesgue Decomposition theorem between a signed measure and a measure**:
Given a signed measure `s` and a σ-finite measure `μ`, there exist a signed measure `t` and a
measurable and integrable function `f`, such that `t` is mutually singular with respect to `μ`
and `s = t + μ.withDensityᵥ f`. In this case `t = s.singularPart μ` and
`f = s.rnDeriv μ`. -/
theorem singularPart_add_withDensity_rnDeriv_eq [s.HaveLebesgueDecomposition μ] :
    s.singularPart μ + μ.withDensityᵥ (s.rnDeriv μ) = s 
goal: s.singularPart μ + μ.withDensityᵥ (s.rnDeriv μ) = s

full_name: MeasureTheory.SignedMeasure.jordanDecomposition_add_withDensity_mutuallySingular
code: theorem jordanDecomposition_add_withDensity_mutuallySingular {f : α → ℝ} (hf : Measurable f)
    (htμ : t ⟂ᵥ μ.toENNRealVectorMeasure) :
    (t.toJordanDecomposition.posPart + μ.withDensity fun x : α => ENNReal.ofReal (f x)) ⟂ₘ
      t.toJordanDecomposition.negPart + μ.withDensity fun x : α => ENNReal.ofReal (-f x) 
goal: (t.toJordanDecomposition.posPart + μ.withDensity fun x => ENNReal.ofReal (f x)) ⟂ₘ
  t.toJordanDecomposition.negPart + μ.withDensity fun x => ENNReal.ofReal (-f x)

full_name: MeasureTheory.SignedMeasure.toJordanDecomposition_eq_of_eq_add_withDensity
code: theorem toJordanDecomposition_eq_of_eq_add_withDensity {f : α → ℝ} (hf : Measurable f)
    (hfi : Integrable f μ) (htμ : t ⟂ᵥ μ.toENNRealVectorMeasure) (hadd : s = t + μ.withDensityᵥ f) :
    s.toJordanDecomposition =
      @JordanDecomposition.mk α _
        (t.toJordanDecomposition.posPart + μ.withDensity fun x => ENNReal.ofReal (f x))
        (t.toJordanDecomposition.negPart + μ.withDensity fun x => ENNReal.ofReal (-f x))
        (by haveI := isFiniteMeasure_withDensity_ofReal hfi.2; infer_instance)
        (by haveI := isFiniteMeasure_withDensity_ofReal hfi.neg.2; infer_instance)
        (jordanDecomposition_add_withDensity_mutuallySingular hf htμ) 
goal: s.toJordanDecomposition =
  MeasureTheory.JordanDecomposition.mk (t.toJordanDecomposition.posPart + μ.withDensity fun x => ENNReal.ofReal (f x))
    (t.toJordanDecomposition.negPart + μ.withDensity fun x => ENNReal.ofReal (-f x)) ⋯

full_name: _private.Mathlib.MeasureTheory.Decomposition.SignedLebesgue.0.MeasureTheory.SignedMeasure.haveLebesgueDecomposition_mk'
code: private theorem haveLebesgueDecomposition_mk' (μ : Measure α) {f : α → ℝ} (hf : Measurable f)
    (hfi : Integrable f μ) (htμ : t ⟂ᵥ μ.toENNRealVectorMeasure) (hadd : s = t + μ.withDensityᵥ f) :
    s.HaveLebesgueDecomposition μ 
goal: s.HaveLebesgueDecomposition μ

full_name: MeasureTheory.SignedMeasure.haveLebesgueDecomposition_mk
code: theorem haveLebesgueDecomposition_mk (μ : Measure α) {f : α → ℝ} (hf : Measurable f)
    (htμ : t ⟂ᵥ μ.toENNRealVectorMeasure) (hadd : s = t + μ.withDensityᵥ f) :
    s.HaveLebesgueDecomposition μ 
goal: s.HaveLebesgueDecomposition μ

full_name: _private.Mathlib.MeasureTheory.Decomposition.SignedLebesgue.0.MeasureTheory.SignedMeasure.eq_singularPart'
code: private theorem eq_singularPart' (t : SignedMeasure α) {f : α → ℝ} (hf : Measurable f)
    (hfi : Integrable f μ) (htμ : t ⟂ᵥ μ.toENNRealVectorMeasure) (hadd : s = t + μ.withDensityᵥ f) :
    t = s.singularPart μ 
goal: t = s.singularPart μ

full_name: MeasureTheory.SignedMeasure.eq_singularPart
code: /-- Given a measure `μ`, signed measures `s` and `t`, and a function `f` such that `t` is
mutually singular with respect to `μ` and `s = t + μ.withDensityᵥ f`, we have
`t = singularPart s μ`, i.e. `t` is the singular part of the Lebesgue decomposition between
`s` and `μ`. -/
theorem eq_singularPart (t : SignedMeasure α) (f : α → ℝ) (htμ : t ⟂ᵥ μ.toENNRealVectorMeasure)
    (hadd : s = t + μ.withDensityᵥ f) : t = s.singularPart μ 
goal: t = s.singularPart μ

full_name: MeasureTheory.SignedMeasure.singularPart_zero
code: theorem singularPart_zero (μ : Measure α) : (0 : SignedMeasure α).singularPart μ = 0 
goal: MeasureTheory.SignedMeasure.singularPart 0 μ = 0

full_name: MeasureTheory.SignedMeasure.singularPart_neg
code: theorem singularPart_neg (s : SignedMeasure α) (μ : Measure α) :
    (-s).singularPart μ = -s.singularPart μ 
goal: (-s).singularPart μ = -s.singularPart μ

full_name: MeasureTheory.SignedMeasure.singularPart_smul_nnreal
code: theorem singularPart_smul_nnreal (s : SignedMeasure α) (μ : Measure α) (r : ℝ≥0) :
    (r • s).singularPart μ = r • s.singularPart μ 
goal: (r • s).singularPart μ = r • s.singularPart μ

full_name: MeasureTheory.SignedMeasure.singularPart_smul
code: nonrec theorem singularPart_smul (s : SignedMeasure α) (μ : Measure α) (r : ℝ) :
    (r • s).singularPart μ = r • s.singularPart μ 
goal: (r • s).singularPart μ = r • s.singularPart μ

full_name: MeasureTheory.SignedMeasure.singularPart_add
code: theorem singularPart_add (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] :
    (s + t).singularPart μ = s.singularPart μ + t.singularPart μ 
goal: (s + t).singularPart μ = s.singularPart μ + t.singularPart μ

full_name: MeasureTheory.SignedMeasure.singularPart_sub
code: theorem singularPart_sub (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] :
    (s - t).singularPart μ = s.singularPart μ - t.singularPart μ 
goal: (s - t).singularPart μ = s.singularPart μ - t.singularPart μ

full_name: MeasureTheory.SignedMeasure.eq_rnDeriv
code: /-- Given a measure `μ`, signed measures `s` and `t`, and a function `f` such that `t` is
mutually singular with respect to `μ` and `s = t + μ.withDensityᵥ f`, we have
`f = rnDeriv s μ`, i.e. `f` is the Radon-Nikodym derivative of `s` and `μ`. -/
theorem eq_rnDeriv (t : SignedMeasure α) (f : α → ℝ) (hfi : Integrable f μ)
    (htμ : t ⟂ᵥ μ.toENNRealVectorMeasure) (hadd : s = t + μ.withDensityᵥ f) :
    f =ᵐ[μ] s.rnDeriv μ 
goal: f =ᵐ[μ] s.rnDeriv μ

full_name: MeasureTheory.SignedMeasure.rnDeriv_neg
code: theorem rnDeriv_neg (s : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ] :
    (-s).rnDeriv μ =ᵐ[μ] -s.rnDeriv μ 
goal: (-s).rnDeriv μ =ᵐ[μ] -s.rnDeriv μ

full_name: MeasureTheory.SignedMeasure.rnDeriv_smul
code: theorem rnDeriv_smul (s : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ] (r : ℝ) :
    (r • s).rnDeriv μ =ᵐ[μ] r • s.rnDeriv μ 
goal: (r • s).rnDeriv μ =ᵐ[μ] r • s.rnDeriv μ

full_name: MeasureTheory.SignedMeasure.rnDeriv_add
code: theorem rnDeriv_add (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] [(s + t).HaveLebesgueDecomposition μ] :
    (s + t).rnDeriv μ =ᵐ[μ] s.rnDeriv μ + t.rnDeriv μ 
goal: (s + t).rnDeriv μ =ᵐ[μ] s.rnDeriv μ + t.rnDeriv μ

full_name: MeasureTheory.SignedMeasure.rnDeriv_sub
code: theorem rnDeriv_sub (s t : SignedMeasure α) (μ : Measure α) [s.HaveLebesgueDecomposition μ]
    [t.HaveLebesgueDecomposition μ] [hst : (s - t).HaveLebesgueDecomposition μ] :
    (s - t).rnDeriv μ =ᵐ[μ] s.rnDeriv μ - t.rnDeriv μ 
goal: (s - t).rnDeriv μ =ᵐ[μ] s.rnDeriv μ - t.rnDeriv μ

full_name: MeasureTheory.ComplexMeasure.HaveLebesgueDecomposition.imPart
code: /-- A complex measure is said to `HaveLebesgueDecomposition` with respect to a positive measure
if both its real and imaginary part `HaveLebesgueDecomposition` with respect to that measure. -/
class HaveLebesgueDecomposition (c : ComplexMeasure α) (μ : Measure α) : Prop where
  rePart : c.re.HaveLebesgueDecomposition μ
  imPart : c.im.HaveLebesgueDecomposition μ
goal: (MeasureTheory.ComplexMeasure.im c).HaveLebesgueDecomposition μ

full_name: MeasureTheory.ComplexMeasure.HaveLebesgueDecomposition.rePart
code: /-- A complex measure is said to `HaveLebesgueDecomposition` with respect to a positive measure
if both its real and imaginary part `HaveLebesgueDecomposition` with respect to that measure. -/
class HaveLebesgueDecomposition (c : ComplexMeasure α) (μ : Measure α) : Prop where
  rePart : c.re.HaveLebesgueDecomposition μ
  imPart : c.im.HaveLebesgueDecomposition μ
goal: (MeasureTheory.ComplexMeasure.re c).HaveLebesgueDecomposition μ

full_name: MeasureTheory.ComplexMeasure.HaveLebesgueDecomposition
code: /-- A complex measure is said to `HaveLebesgueDecomposition` with respect to a positive measure
if both its real and imaginary part `HaveLebesgueDecomposition` with respect to that measure. -/
class HaveLebesgueDecomposition (c : ComplexMeasure α) (μ : Measure α) : Prop where
  rePart : c.re.HaveLebesgueDecomposition μ
  imPart : c.im.HaveLebesgueDecomposition μ
goal: Prop

full_name: MeasureTheory.ComplexMeasure.singularPart
code: /-- The singular part between a complex measure `c` and a positive measure `μ` is the complex
measure satisfying `c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c`. This property is given
by `MeasureTheory.ComplexMeasure.singularPart_add_withDensity_rnDeriv_eq`. -/
def singularPart (c : ComplexMeasure α) (μ : Measure α) : ComplexMeasure α 
goal: MeasureTheory.ComplexMeasure α

full_name: MeasureTheory.ComplexMeasure.rnDeriv
code: /-- The Radon-Nikodym derivative between a complex measure and a positive measure. -/
def rnDeriv (c : ComplexMeasure α) (μ : Measure α) : α → ℂ 
goal: α → ℂ

full_name: MeasureTheory.ComplexMeasure.integrable_rnDeriv
code: theorem integrable_rnDeriv (c : ComplexMeasure α) (μ : Measure α) : Integrable (c.rnDeriv μ) μ 
goal: MeasureTheory.Integrable (c.rnDeriv μ) μ

full_name: MeasureTheory.ComplexMeasure.singularPart_add_withDensity_rnDeriv_eq
code: theorem singularPart_add_withDensity_rnDeriv_eq [c.HaveLebesgueDecomposition μ] :
    c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c 
goal: c.singularPart μ + μ.withDensityᵥ (c.rnDeriv μ) = c