File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

full_name: MeasureTheory.JordanDecomposition.posPart
code: /-- A Jordan decomposition of a measurable space is a pair of mutually singular,
finite measures. -/
@[ext]
structure JordanDecomposition (α : Type*) [MeasurableSpace α] where
  (posPart negPart : Measure α)
  [posPart_finite : IsFiniteMeasure posPart]
  [negPart_finite : IsFiniteMeasure negPart]
  mutuallySingular : posPart ⟂ₘ negPart
goal: MeasureTheory.Measure α

full_name: MeasureTheory.JordanDecomposition.mutuallySingular
code: /-- A Jordan decomposition of a measurable space is a pair of mutually singular,
finite measures. -/
@[ext]
structure JordanDecomposition (α : Type*) [MeasurableSpace α] where
  (posPart negPart : Measure α)
  [posPart_finite : IsFiniteMeasure posPart]
  [negPart_finite : IsFiniteMeasure negPart]
  mutuallySingular : posPart ⟂ₘ negPart
goal: self.posPart ⟂ₘ self.negPart

full_name: MeasureTheory.JordanDecomposition
code: /-- A Jordan decomposition of a measurable space is a pair of mutually singular,
finite measures. -/
@[ext]
structure JordanDecomposition (α : Type*) [MeasurableSpace α] where
  (posPart negPart : Measure α)
  [posPart_finite : IsFiniteMeasure posPart]
  [negPart_finite : IsFiniteMeasure negPart]
  mutuallySingular : posPart ⟂ₘ negPart
goal: Type u_3

full_name: MeasureTheory.JordanDecomposition.negPart_finite
code: /-- A Jordan decomposition of a measurable space is a pair of mutually singular,
finite measures. -/
@[ext]
structure JordanDecomposition (α : Type*) [MeasurableSpace α] where
  (posPart negPart : Measure α)
  [posPart_finite : IsFiniteMeasure posPart]
  [negPart_finite : IsFiniteMeasure negPart]
  mutuallySingular : posPart ⟂ₘ negPart
goal: MeasureTheory.IsFiniteMeasure self.negPart

full_name: MeasureTheory.JordanDecomposition.posPart_finite
code: /-- A Jordan decomposition of a measurable space is a pair of mutually singular,
finite measures. -/
@[ext]
structure JordanDecomposition (α : Type*) [MeasurableSpace α] where
  (posPart negPart : Measure α)
  [posPart_finite : IsFiniteMeasure posPart]
  [negPart_finite : IsFiniteMeasure negPart]
  mutuallySingular : posPart ⟂ₘ negPart
goal: MeasureTheory.IsFiniteMeasure self.posPart

full_name: MeasureTheory.JordanDecomposition.negPart
code: /-- A Jordan decomposition of a measurable space is a pair of mutually singular,
finite measures. -/
@[ext]
structure JordanDecomposition (α : Type*) [MeasurableSpace α] where
  (posPart negPart : Measure α)
  [posPart_finite : IsFiniteMeasure posPart]
  [negPart_finite : IsFiniteMeasure negPart]
  mutuallySingular : posPart ⟂ₘ negPart
goal: MeasureTheory.Measure α

full_name: MeasureTheory.JordanDecomposition.instZero
code: instance instZero : Zero (JordanDecomposition α) 
goal: Zero (MeasureTheory.JordanDecomposition α)

full_name: MeasureTheory.JordanDecomposition.instInhabited
code: instance instInhabited : Inhabited (JordanDecomposition α) 
goal: Inhabited (MeasureTheory.JordanDecomposition α)

full_name: MeasureTheory.JordanDecomposition.instInvolutiveNeg
code: instance instInvolutiveNeg : InvolutiveNeg (JordanDecomposition α) 
goal: InvolutiveNeg (MeasureTheory.JordanDecomposition α)

full_name: MeasureTheory.JordanDecomposition.instSMul
code: instance instSMul : SMul ℝ≥0 (JordanDecomposition α) 
goal: SMul ℝ≥0 (MeasureTheory.JordanDecomposition α)

full_name: MeasureTheory.JordanDecomposition.instSMulReal
code: instance instSMulReal : SMul ℝ (JordanDecomposition α) 
goal: SMul ℝ (MeasureTheory.JordanDecomposition α)

full_name: MeasureTheory.JordanDecomposition.zero_posPart
code: @[simp]
theorem zero_posPart : (0 : JordanDecomposition α).posPart = 0 
goal: MeasureTheory.JordanDecomposition.posPart 0 = 0

full_name: MeasureTheory.JordanDecomposition.zero_negPart
code: @[simp]
theorem zero_negPart : (0 : JordanDecomposition α).negPart = 0 
goal: MeasureTheory.JordanDecomposition.negPart 0 = 0

full_name: MeasureTheory.JordanDecomposition.neg_posPart
code: @[simp]
theorem neg_posPart : (-j).posPart = j.negPart 
goal: (-j).posPart = j.negPart

full_name: MeasureTheory.JordanDecomposition.neg_negPart
code: @[simp]
theorem neg_negPart : (-j).negPart = j.posPart 
goal: (-j).negPart = j.posPart

full_name: MeasureTheory.JordanDecomposition.smul_posPart
code: @[simp]
theorem smul_posPart (r : ℝ≥0) : (r • j).posPart = r • j.posPart 
goal: (r • j).posPart = r • j.posPart

full_name: MeasureTheory.JordanDecomposition.smul_negPart
code: @[simp]
theorem smul_negPart (r : ℝ≥0) : (r • j).negPart = r • j.negPart 
goal: (r • j).negPart = r • j.negPart

full_name: MeasureTheory.JordanDecomposition.real_smul_def
code: theorem real_smul_def (r : ℝ) (j : JordanDecomposition α) :
    r • j = if 0 ≤ r then r.toNNReal • j else -((-r).toNNReal • j) 
goal: r • j = if 0 ≤ r then r.toNNReal • j else -((-r).toNNReal • j)

full_name: MeasureTheory.JordanDecomposition.coe_smul
code: @[simp]
theorem coe_smul (r : ℝ≥0) : (r : ℝ) • j = r • j 
goal: ↑r • j = r • j

full_name: MeasureTheory.JordanDecomposition.real_smul_nonneg
code: theorem real_smul_nonneg (r : ℝ) (hr : 0 ≤ r) : r • j = r.toNNReal • j 
goal: r • j = r.toNNReal • j

full_name: MeasureTheory.JordanDecomposition.real_smul_neg
code: theorem real_smul_neg (r : ℝ) (hr : r < 0) : r • j = -((-r).toNNReal • j) 
goal: r • j = -((-r).toNNReal • j)

full_name: MeasureTheory.JordanDecomposition.real_smul_posPart_nonneg
code: theorem real_smul_posPart_nonneg (r : ℝ) (hr : 0 ≤ r) :
    (r • j).posPart = r.toNNReal • j.posPart 
goal: (r • j).posPart = r.toNNReal • j.posPart

full_name: MeasureTheory.JordanDecomposition.real_smul_negPart_nonneg
code: theorem real_smul_negPart_nonneg (r : ℝ) (hr : 0 ≤ r) :
    (r • j).negPart = r.toNNReal • j.negPart 
goal: (r • j).negPart = r.toNNReal • j.negPart

full_name: MeasureTheory.JordanDecomposition.real_smul_posPart_neg
code: theorem real_smul_posPart_neg (r : ℝ) (hr : r < 0) :
    (r • j).posPart = (-r).toNNReal • j.negPart 
goal: (r • j).posPart = (-r).toNNReal • j.negPart

full_name: MeasureTheory.JordanDecomposition.real_smul_negPart_neg
code: theorem real_smul_negPart_neg (r : ℝ) (hr : r < 0) :
    (r • j).negPart = (-r).toNNReal • j.posPart 
goal: (r • j).negPart = (-r).toNNReal • j.posPart

full_name: MeasureTheory.JordanDecomposition.toSignedMeasure
code: /-- The signed measure associated with a Jordan decomposition. -/
def toSignedMeasure : SignedMeasure α 
goal: MeasureTheory.SignedMeasure α

full_name: MeasureTheory.JordanDecomposition.toSignedMeasure_zero
code: theorem toSignedMeasure_zero : (0 : JordanDecomposition α).toSignedMeasure = 0 
goal: MeasureTheory.JordanDecomposition.toSignedMeasure 0 = 0

full_name: MeasureTheory.JordanDecomposition.toSignedMeasure_neg
code: theorem toSignedMeasure_neg : (-j).toSignedMeasure = -j.toSignedMeasure 
goal: (-j).toSignedMeasure = -j.toSignedMeasure

full_name: MeasureTheory.JordanDecomposition.toSignedMeasure_smul
code: theorem toSignedMeasure_smul (r : ℝ≥0) : (r • j).toSignedMeasure = r • j.toSignedMeasure 
goal: (r • j).toSignedMeasure = r • j.toSignedMeasure

full_name: MeasureTheory.JordanDecomposition.exists_compl_positive_negative
code: /-- A Jordan decomposition provides a Hahn decomposition. -/
theorem exists_compl_positive_negative :
    ∃ S : Set α,
      MeasurableSet S ∧
        j.toSignedMeasure ≤[S] 0 ∧
          0 ≤[Sᶜ] j.toSignedMeasure ∧ j.posPart S = 0 ∧ j.negPart Sᶜ = 0 
goal: ∃ S,
  MeasurableSet S ∧
    MeasureTheory.VectorMeasure.restrict j.toSignedMeasure S ≤ MeasureTheory.VectorMeasure.restrict 0 S ∧
      MeasureTheory.VectorMeasure.restrict 0 Sᶜ ≤ MeasureTheory.VectorMeasure.restrict j.toSignedMeasure Sᶜ ∧
        j.posPart S = 0 ∧ j.negPart Sᶜ = 0

full_name: MeasureTheory.SignedMeasure.toJordanDecomposition
code: /-- Given a signed measure `s`, `s.toJordanDecomposition` is the Jordan decomposition `j`,
such that `s = j.toSignedMeasure`. This property is known as the Jordan decomposition
theorem, and is shown by
`MeasureTheory.SignedMeasure.toSignedMeasure_toJordanDecomposition`. -/
def toJordanDecomposition (s : SignedMeasure α) : JordanDecomposition α 
goal: MeasureTheory.JordanDecomposition α

full_name: MeasureTheory.SignedMeasure.toJordanDecomposition_spec
code: theorem toJordanDecomposition_spec (s : SignedMeasure α) :
    ∃ (i : Set α) (hi₁ : MeasurableSet i) (hi₂ : 0 ≤[i] s) (hi₃ : s ≤[iᶜ] 0),
      s.toJordanDecomposition.posPart = s.toMeasureOfZeroLE i hi₁ hi₂ ∧
        s.toJordanDecomposition.negPart = s.toMeasureOfLEZero iᶜ hi₁.compl hi₃ 
goal: ∃ i,
  ∃ (hi₁ : MeasurableSet i) (hi₂ : MeasureTheory.VectorMeasure.restrict 0 i ≤ MeasureTheory.VectorMeasure.restrict s i)
    (hi₃ : MeasureTheory.VectorMeasure.restrict s iᶜ ≤ MeasureTheory.VectorMeasure.restrict 0 iᶜ),
    s.toJordanDecomposition.posPart = s.toMeasureOfZeroLE i hi₁ hi₂ ∧
      s.toJordanDecomposition.negPart = s.toMeasureOfLEZero iᶜ ⋯ hi₃

full_name: MeasureTheory.SignedMeasure.toSignedMeasure_toJordanDecomposition
code: /-- **The Jordan decomposition theorem**: Given a signed measure `s`, there exists a pair of
mutually singular measures `μ` and `ν` such that `s = μ - ν`. In this case, the measures `μ`
and `ν` are given by `s.toJordanDecomposition.posPart` and
`s.toJordanDecomposition.negPart` respectively.

Note that we use `MeasureTheory.JordanDecomposition.toSignedMeasure` to represent the
signed measure corresponding to
`s.toJordanDecomposition.posPart - s.toJordanDecomposition.negPart`. -/
@[simp]
theorem toSignedMeasure_toJordanDecomposition (s : SignedMeasure α) :
    s.toJordanDecomposition.toSignedMeasure = s 
goal: s.toJordanDecomposition.toSignedMeasure = s

full_name: MeasureTheory.SignedMeasure.subset_positive_null_set
code: /-- A subset `v` of a null-set `w` has zero measure if `w` is a subset of a positive set `u`. -/
theorem subset_positive_null_set (hu : MeasurableSet u) (hv : MeasurableSet v)
    (hw : MeasurableSet w) (hsu : 0 ≤[u] s) (hw₁ : s w = 0) (hw₂ : w ⊆ u) (hwt : v ⊆ w) :
    s v = 0 
goal: ↑s v = 0

full_name: MeasureTheory.SignedMeasure.subset_negative_null_set
code: /-- A subset `v` of a null-set `w` has zero measure if `w` is a subset of a negative set `u`. -/
theorem subset_negative_null_set (hu : MeasurableSet u) (hv : MeasurableSet v)
    (hw : MeasurableSet w) (hsu : s ≤[u] 0) (hw₁ : s w = 0) (hw₂ : w ⊆ u) (hwt : v ⊆ w) :
    s v = 0 
goal: ↑s v = 0

full_name: MeasureTheory.SignedMeasure.of_diff_eq_zero_of_symmDiff_eq_zero_positive
code: /-- If the symmetric difference of two positive sets is a null-set, then so are the differences
between the two sets. -/
theorem of_diff_eq_zero_of_symmDiff_eq_zero_positive (hu : MeasurableSet u) (hv : MeasurableSet v)
    (hsu : 0 ≤[u] s) (hsv : 0 ≤[v] s) (hs : s (u ∆ v) = 0) : s (u \ v) = 0 ∧ s (v \ u) = 0 
goal: ↑s (u \ v) = 0 ∧ ↑s (v \ u) = 0

full_name: MeasureTheory.SignedMeasure.of_diff_eq_zero_of_symmDiff_eq_zero_negative
code: /-- If the symmetric difference of two negative sets is a null-set, then so are the differences
between the two sets. -/
theorem of_diff_eq_zero_of_symmDiff_eq_zero_negative (hu : MeasurableSet u) (hv : MeasurableSet v)
    (hsu : s ≤[u] 0) (hsv : s ≤[v] 0) (hs : s (u ∆ v) = 0) : s (u \ v) = 0 ∧ s (v \ u) = 0 
goal: ↑s (u \ v) = 0 ∧ ↑s (v \ u) = 0

full_name: MeasureTheory.SignedMeasure.of_inter_eq_of_symmDiff_eq_zero_positive
code: theorem of_inter_eq_of_symmDiff_eq_zero_positive (hu : MeasurableSet u) (hv : MeasurableSet v)
    (hw : MeasurableSet w) (hsu : 0 ≤[u] s) (hsv : 0 ≤[v] s) (hs : s (u ∆ v) = 0) :
    s (w ∩ u) = s (w ∩ v) 
goal: ↑s (w ∩ u) = ↑s (w ∩ v)

full_name: MeasureTheory.SignedMeasure.of_inter_eq_of_symmDiff_eq_zero_negative
code: theorem of_inter_eq_of_symmDiff_eq_zero_negative (hu : MeasurableSet u) (hv : MeasurableSet v)
    (hw : MeasurableSet w) (hsu : s ≤[u] 0) (hsv : s ≤[v] 0) (hs : s (u ∆ v) = 0) :
    s (w ∩ u) = s (w ∩ v) 
goal: ↑s (w ∩ u) = ↑s (w ∩ v)

full_name: _private.Mathlib.MeasureTheory.Decomposition.Jordan.0.MeasureTheory.JordanDecomposition.eq_of_posPart_eq_posPart
code: private theorem eq_of_posPart_eq_posPart {j₁ j₂ : JordanDecomposition α}
    (hj : j₁.posPart = j₂.posPart) (hj' : j₁.toSignedMeasure = j₂.toSignedMeasure) : j₁ = j₂ 
goal: j₁ = j₂

full_name: MeasureTheory.JordanDecomposition.toSignedMeasure_injective
code: /-- The Jordan decomposition of a signed measure is unique. -/
theorem toSignedMeasure_injective : Injective <| @JordanDecomposition.toSignedMeasure α _ 
goal: Function.Injective MeasureTheory.JordanDecomposition.toSignedMeasure

full_name: MeasureTheory.JordanDecomposition.toJordanDecomposition_toSignedMeasure
code: @[simp]
theorem toJordanDecomposition_toSignedMeasure (j : JordanDecomposition α) :
    j.toSignedMeasure.toJordanDecomposition = j 
goal: j.toSignedMeasure.toJordanDecomposition = j

full_name: MeasureTheory.SignedMeasure.toJordanDecompositionEquiv_symm_apply
code: /-- `MeasureTheory.SignedMeasure.toJordanDecomposition` and
`MeasureTheory.JordanDecomposition.toSignedMeasure` form an `Equiv`. -/
@[simps apply symm_apply]
def toJordanDecompositionEquiv (α : Type*) [MeasurableSpace α] :
    SignedMeasure α ≃ JordanDecomposition α 
goal: (MeasureTheory.SignedMeasure.toJordanDecompositionEquiv α).symm j = j.toSignedMeasure

full_name: MeasureTheory.SignedMeasure.toJordanDecompositionEquiv
code: /-- `MeasureTheory.SignedMeasure.toJordanDecomposition` and
`MeasureTheory.JordanDecomposition.toSignedMeasure` form an `Equiv`. -/
@[simps apply symm_apply]
def toJordanDecompositionEquiv (α : Type*) [MeasurableSpace α] :
    SignedMeasure α ≃ JordanDecomposition α 
goal: MeasureTheory.SignedMeasure α ≃ MeasureTheory.JordanDecomposition α

full_name: MeasureTheory.SignedMeasure.toJordanDecompositionEquiv_apply
code: /-- `MeasureTheory.SignedMeasure.toJordanDecomposition` and
`MeasureTheory.JordanDecomposition.toSignedMeasure` form an `Equiv`. -/
@[simps apply symm_apply]
def toJordanDecompositionEquiv (α : Type*) [MeasurableSpace α] :
    SignedMeasure α ≃ JordanDecomposition α 
goal: (MeasureTheory.SignedMeasure.toJordanDecompositionEquiv α) s = s.toJordanDecomposition

full_name: MeasureTheory.SignedMeasure.toJordanDecomposition_zero
code: theorem toJordanDecomposition_zero : (0 : SignedMeasure α).toJordanDecomposition = 0 
goal: MeasureTheory.SignedMeasure.toJordanDecomposition 0 = 0

full_name: MeasureTheory.SignedMeasure.toJordanDecomposition_neg
code: theorem toJordanDecomposition_neg (s : SignedMeasure α) :
    (-s).toJordanDecomposition = -s.toJordanDecomposition 
goal: (-s).toJordanDecomposition = -s.toJordanDecomposition

full_name: MeasureTheory.SignedMeasure.toJordanDecomposition_smul
code: theorem toJordanDecomposition_smul (s : SignedMeasure α) (r : ℝ≥0) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition 
goal: (r • s).toJordanDecomposition = r • s.toJordanDecomposition

full_name: _private.Mathlib.MeasureTheory.Decomposition.Jordan.0.MeasureTheory.SignedMeasure.toJordanDecomposition_smul_real_nonneg
code: private theorem toJordanDecomposition_smul_real_nonneg (s : SignedMeasure α) (r : ℝ)
    (hr : 0 ≤ r) : (r • s).toJordanDecomposition = r • s.toJordanDecomposition 
goal: (r • s).toJordanDecomposition = r • s.toJordanDecomposition

full_name: MeasureTheory.SignedMeasure.toJordanDecomposition_smul_real
code: theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition 
goal: (r • s).toJordanDecomposition = r • s.toJordanDecomposition

full_name: MeasureTheory.SignedMeasure.toJordanDecomposition_eq
code: theorem toJordanDecomposition_eq {s : SignedMeasure α} {j : JordanDecomposition α}
    (h : s = j.toSignedMeasure) : s.toJordanDecomposition = j 
goal: s.toJordanDecomposition = j

full_name: MeasureTheory.SignedMeasure.totalVariation
code: /-- The total variation of a signed measure. -/
def totalVariation (s : SignedMeasure α) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.SignedMeasure.totalVariation_zero
code: theorem totalVariation_zero : (0 : SignedMeasure α).totalVariation = 0 
goal: MeasureTheory.SignedMeasure.totalVariation 0 = 0

full_name: MeasureTheory.SignedMeasure.totalVariation_neg
code: theorem totalVariation_neg (s : SignedMeasure α) : (-s).totalVariation = s.totalVariation 
goal: (-s).totalVariation = s.totalVariation

full_name: MeasureTheory.SignedMeasure.null_of_totalVariation_zero
code: theorem null_of_totalVariation_zero (s : SignedMeasure α) {i : Set α}
    (hs : s.totalVariation i = 0) : s i = 0 
goal: ↑s i = 0

full_name: MeasureTheory.SignedMeasure.absolutelyContinuous_ennreal_iff
code: theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure 
goal: s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure

full_name: MeasureTheory.SignedMeasure.totalVariation_absolutelyContinuous_iff
code: theorem totalVariation_absolutelyContinuous_iff (s : SignedMeasure α) (μ : Measure α) :
    s.totalVariation ≪ μ ↔
      s.toJordanDecomposition.posPart ≪ μ ∧ s.toJordanDecomposition.negPart ≪ μ 
goal: s.totalVariation ≪ μ ↔ s.toJordanDecomposition.posPart ≪ μ ∧ s.toJordanDecomposition.negPart ≪ μ

full_name: MeasureTheory.SignedMeasure.mutuallySingular_iff
code: theorem mutuallySingular_iff (s t : SignedMeasure α) :
    s ⟂ᵥ t ↔ s.totalVariation ⟂ₘ t.totalVariation 
goal: s ⟂ᵥ t ↔ s.totalVariation ⟂ₘ t.totalVariation

full_name: MeasureTheory.SignedMeasure.mutuallySingular_ennreal_iff
code: theorem mutuallySingular_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ⟂ᵥ μ ↔ s.totalVariation ⟂ₘ μ.ennrealToMeasure 
goal: s ⟂ᵥ μ ↔ s.totalVariation ⟂ₘ μ.ennrealToMeasure

full_name: MeasureTheory.SignedMeasure.totalVariation_mutuallySingular_iff
code: theorem totalVariation_mutuallySingular_iff (s : SignedMeasure α) (μ : Measure α) :
    s.totalVariation ⟂ₘ μ ↔
      s.toJordanDecomposition.posPart ⟂ₘ μ ∧ s.toJordanDecomposition.negPart ⟂ₘ μ 
goal: s.totalVariation ⟂ₘ μ ↔ s.toJordanDecomposition.posPart ⟂ₘ μ ∧ s.toJordanDecomposition.negPart ⟂ₘ μ