l3lab/ntp-mathlib huggingface dataset:
instance haveLebesgueDecomposition_smul_real (s : SignedMeasure α) (μ : Measure α)
    [s.HaveLebesgueDecomposition μ] (r : ℝ) : (r • s).HaveLebesgueDecomposition μ := by
  by_cases hr : 0 ≤ r
  · lift r to ℝ≥0 using hr
    exact s.haveLebesgueDecomposition_smul μ _
  · rw [not_le] at hr
    

Proof state:
case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
r : ℝ
hr : r < 0
⊢ HaveLebesgueDecomposition (r • s) μ

Next tactic:
refine'
      { posPart := by
          rw [toJordanDecomposition_smul_real, JordanDecomposition.real_smul_posPart_neg _ _ hr]
          infer_instance
        negPart := by
          rw [toJordanDecomposition_smul_real, JordanDecomposition.real_smul_negPart_neg _ _ hr]
          infer_instance }
instance haveLebesgueDecomposition_smul_real (s : SignedMeasure α) (μ : Measure α)
    [s.HaveLebesgueDecomposition μ] (r : ℝ) : (r • s).HaveLebesgueDecomposition μ := by
  by_cases hr : 0 ≤ r
  · lift r to ℝ≥0 using hr
    exact s.haveLebesgueDecomposition_smul μ _
  · rw [not_le] at hr
    refine'
      { posPart := by
          

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
r : ℝ
hr : r < 0
⊢ Measure.HaveLebesgueDecomposition (toJordanDecomposition (r • s)).posPart μ

Next tactic:
rw [toJordanDecomposition_smul_real, JordanDecomposition.real_smul_posPart_neg _ _ hr]
instance haveLebesgueDecomposition_smul_real (s : SignedMeasure α) (μ : Measure α)
    [s.HaveLebesgueDecomposition μ] (r : ℝ) : (r • s).HaveLebesgueDecomposition μ := by
  by_cases hr : 0 ≤ r
  · lift r to ℝ≥0 using hr
    exact s.haveLebesgueDecomposition_smul μ _
  · rw [not_le] at hr
    refine'
      { posPart := by
          rw [toJordanDecomposition_smul_real, JordanDecomposition.real_smul_posPart_neg _ _ hr]
          

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
r : ℝ
hr : r < 0
⊢ Measure.HaveLebesgueDecomposition (Real.toNNReal (-r) • (toJordanDecomposition s).negPart) μ

Next tactic:
infer_instance
instance haveLebesgueDecomposition_smul_real (s : SignedMeasure α) (μ : Measure α)
    [s.HaveLebesgueDecomposition μ] (r : ℝ) : (r • s).HaveLebesgueDecomposition μ := by
  by_cases hr : 0 ≤ r
  · lift r to ℝ≥0 using hr
    exact s.haveLebesgueDecomposition_smul μ _
  · rw [not_le] at hr
    refine'
      { posPart := by
          rw [toJordanDecomposition_smul_real, JordanDecomposition.real_smul_posPart_neg _ _ hr]
          infer_instance
        negPart := by
          

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
r : ℝ
hr : r < 0
⊢ Measure.HaveLebesgueDecomposition (toJordanDecomposition (r • s)).negPart μ

Next tactic:
rw [toJordanDecomposition_smul_real, JordanDecomposition.real_smul_negPart_neg _ _ hr]
instance haveLebesgueDecomposition_smul_real (s : SignedMeasure α) (μ : Measure α)
    [s.HaveLebesgueDecomposition μ] (r : ℝ) : (r • s).HaveLebesgueDecomposition μ := by
  by_cases hr : 0 ≤ r
  · lift r to ℝ≥0 using hr
    exact s.haveLebesgueDecomposition_smul μ _
  · rw [not_le] at hr
    refine'
      { posPart := by
          rw [toJordanDecomposition_smul_real, JordanDecomposition.real_smul_posPart_neg _ _ hr]
          infer_instance
        negPart := by
          rw [toJordanDecomposition_smul_real, JordanDecomposition.real_smul_negPart_neg _ _ hr]
          

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
r : ℝ
hr : r < 0
⊢ Measure.HaveLebesgueDecomposition (Real.toNNReal (-r) • (toJordanDecomposition s).posPart) μ

Next tactic:
infer_instance
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
by_cases hl : s.HaveLebesgueDecomposition μ
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hl : HaveLebesgueDecomposition s μ
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
    

Proof state:
case pos.intro.intro.intro
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hl : HaveLebesgueDecomposition s μ
i : Set α
hi : MeasurableSet i
hpos : ↑↑(toJordanDecomposition s).posPart i = 0
hneg : ↑↑(toJordanDecomposition s).negPart iᶜ = 0
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
rw [s.toJordanDecomposition.posPart.haveLebesgueDecomposition_add μ] at hpos
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
    rw [s.toJordanDecomposition.posPart.haveLebesgueDecomposition_add μ] at hpos
    

Proof state:
case pos.intro.intro.intro
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hl : HaveLebesgueDecomposition s μ
i : Set α
hi : MeasurableSet i
hpos :
  ↑↑(Measure.singularPart (toJordanDecomposition s).posPart μ +
            withDensity μ (rnDeriv (toJordanDecomposition s).posPart μ))
      i =
    0
hneg : ↑↑(toJordanDecomposition s).negPart iᶜ = 0
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
rw [s.toJordanDecomposition.negPart.haveLebesgueDecomposition_add μ] at hneg
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
    rw [s.toJordanDecomposition.posPart.haveLebesgueDecomposition_add μ] at hpos
    rw [s.toJordanDecomposition.negPart.haveLebesgueDecomposition_add μ] at hneg
    

Proof state:
case pos.intro.intro.intro
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hl : HaveLebesgueDecomposition s μ
i : Set α
hi : MeasurableSet i
hpos :
  ↑↑(Measure.singularPart (toJordanDecomposition s).posPart μ +
            withDensity μ (rnDeriv (toJordanDecomposition s).posPart μ))
      i =
    0
hneg :
  ↑↑(Measure.singularPart (toJordanDecomposition s).negPart μ +
            withDensity μ (rnDeriv (toJordanDecomposition s).negPart μ))
      iᶜ =
    0
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
rw [add_apply, add_eq_zero_iff] at hpos hneg
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
    rw [s.toJordanDecomposition.posPart.haveLebesgueDecomposition_add μ] at hpos
    rw [s.toJordanDecomposition.negPart.haveLebesgueDecomposition_add μ] at hneg
    rw [add_apply, add_eq_zero_iff] at hpos hneg
    

Proof state:
case pos.intro.intro.intro
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hl : HaveLebesgueDecomposition s μ
i : Set α
hi : MeasurableSet i
hpos :
  ↑↑(Measure.singularPart (toJordanDecomposition s).posPart μ) i = 0 ∧
    ↑↑(withDensity μ (rnDeriv (toJordanDecomposition s).posPart μ)) i = 0
hneg :
  ↑↑(Measure.singularPart (toJordanDecomposition s).negPart μ) iᶜ = 0 ∧
    ↑↑(withDensity μ (rnDeriv (toJordanDecomposition s).negPart μ)) iᶜ = 0
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
exact ⟨i, hi, hpos.1, hneg.1⟩
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
    rw [s.toJordanDecomposition.posPart.haveLebesgueDecomposition_add μ] at hpos
    rw [s.toJordanDecomposition.negPart.haveLebesgueDecomposition_add μ] at hneg
    rw [add_apply, add_eq_zero_iff] at hpos hneg
    exact ⟨i, hi, hpos.1, hneg.1⟩
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hl : ¬HaveLebesgueDecomposition s μ
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
rw [not_haveLebesgueDecomposition_iff] at hl
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
    rw [s.toJordanDecomposition.posPart.haveLebesgueDecomposition_add μ] at hpos
    rw [s.toJordanDecomposition.negPart.haveLebesgueDecomposition_add μ] at hneg
    rw [add_apply, add_eq_zero_iff] at hpos hneg
    exact ⟨i, hi, hpos.1, hneg.1⟩
  · rw [not_haveLebesgueDecomposition_iff] at hl
    

Proof state:
case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hl :
  ¬Measure.HaveLebesgueDecomposition (toJordanDecomposition s).posPart μ ∨
    ¬Measure.HaveLebesgueDecomposition (toJordanDecomposition s).negPart μ
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
cases' hl with hp hn
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
    rw [s.toJordanDecomposition.posPart.haveLebesgueDecomposition_add μ] at hpos
    rw [s.toJordanDecomposition.negPart.haveLebesgueDecomposition_add μ] at hneg
    rw [add_apply, add_eq_zero_iff] at hpos hneg
    exact ⟨i, hi, hpos.1, hneg.1⟩
  · rw [not_haveLebesgueDecomposition_iff] at hl
    cases' hl with hp hn
    · 

Proof state:
case neg.inl
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hp : ¬Measure.HaveLebesgueDecomposition (toJordanDecomposition s).posPart μ
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
rw [Measure.singularPart, dif_neg hp]
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
    rw [s.toJordanDecomposition.posPart.haveLebesgueDecomposition_add μ] at hpos
    rw [s.toJordanDecomposition.negPart.haveLebesgueDecomposition_add μ] at hneg
    rw [add_apply, add_eq_zero_iff] at hpos hneg
    exact ⟨i, hi, hpos.1, hneg.1⟩
  · rw [not_haveLebesgueDecomposition_iff] at hl
    cases' hl with hp hn
    · rw [Measure.singularPart, dif_neg hp]
      

Proof state:
case neg.inl
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hp : ¬Measure.HaveLebesgueDecomposition (toJordanDecomposition s).posPart μ
⊢ 0 ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
exact MutuallySingular.zero_left
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
    rw [s.toJordanDecomposition.posPart.haveLebesgueDecomposition_add μ] at hpos
    rw [s.toJordanDecomposition.negPart.haveLebesgueDecomposition_add μ] at hneg
    rw [add_apply, add_eq_zero_iff] at hpos hneg
    exact ⟨i, hi, hpos.1, hneg.1⟩
  · rw [not_haveLebesgueDecomposition_iff] at hl
    cases' hl with hp hn
    · rw [Measure.singularPart, dif_neg hp]
      exact MutuallySingular.zero_left
    · 

Proof state:
case neg.inr
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hn : ¬Measure.HaveLebesgueDecomposition (toJordanDecomposition s).negPart μ
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
rw [Measure.singularPart, Measure.singularPart, dif_neg hn]
theorem singularPart_mutuallySingular (s : SignedMeasure α) (μ : Measure α) :
    s.toJordanDecomposition.posPart.singularPart μ ⟂ₘ
      s.toJordanDecomposition.negPart.singularPart μ := by
  by_cases hl : s.HaveLebesgueDecomposition μ
  · obtain ⟨i, hi, hpos, hneg⟩ := s.toJordanDecomposition.mutuallySingular
    rw [s.toJordanDecomposition.posPart.haveLebesgueDecomposition_add μ] at hpos
    rw [s.toJordanDecomposition.negPart.haveLebesgueDecomposition_add μ] at hneg
    rw [add_apply, add_eq_zero_iff] at hpos hneg
    exact ⟨i, hi, hpos.1, hneg.1⟩
  · rw [not_haveLebesgueDecomposition_iff] at hl
    cases' hl with hp hn
    · rw [Measure.singularPart, dif_neg hp]
      exact MutuallySingular.zero_left
    · rw [Measure.singularPart, Measure.singularPart, dif_neg hn]
      

Proof state:
case neg.inr
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
hn : ¬Measure.HaveLebesgueDecomposition (toJordanDecomposition s).negPart μ
⊢ (if h : Measure.HaveLebesgueDecomposition (toJordanDecomposition s).posPart μ then
      (Classical.choose
          (_ : ∃ p, Measurable p.2 ∧ p.1 ⟂ₘ μ ∧ (toJordanDecomposition s).posPart = p.1 + withDensity μ p.2)).1
    else 0) ⟂ₘ
    0

Next tactic:
exact MutuallySingular.zero_right
theorem singularPart_totalVariation (s : SignedMeasure α) (μ : Measure α) :
    (s.singularPart μ).totalVariation =
      s.toJordanDecomposition.posPart.singularPart μ +
        s.toJordanDecomposition.negPart.singularPart μ := by
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ totalVariation (singularPart s μ) =
    Measure.singularPart (toJordanDecomposition s).posPart μ + Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
have :
    (s.singularPart μ).toJordanDecomposition =
      ⟨s.toJordanDecomposition.posPart.singularPart μ,
        s.toJordanDecomposition.negPart.singularPart μ, singularPart_mutuallySingular s μ⟩ := by
    refine' JordanDecomposition.toSignedMeasure_injective _
    rw [toSignedMeasure_toJordanDecomposition, singularPart, JordanDecomposition.toSignedMeasure]
theorem singularPart_totalVariation (s : SignedMeasure α) (μ : Measure α) :
    (s.singularPart μ).totalVariation =
      s.toJordanDecomposition.posPart.singularPart μ +
        s.toJordanDecomposition.negPart.singularPart μ := by
  have :
    (s.singularPart μ).toJordanDecomposition =
      ⟨s.toJordanDecomposition.posPart.singularPart μ,
        s.toJordanDecomposition.negPart.singularPart μ, singularPart_mutuallySingular s μ⟩ := by
    

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ toJordanDecomposition (singularPart s μ) =
    JordanDecomposition.mk (Measure.singularPart (toJordanDecomposition s).posPart μ)
      (Measure.singularPart (toJordanDecomposition s).negPart μ)
      (_ :
        Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ
          Measure.singularPart (toJordanDecomposition s).negPart μ)

Next tactic:
refine' JordanDecomposition.toSignedMeasure_injective _
theorem singularPart_totalVariation (s : SignedMeasure α) (μ : Measure α) :
    (s.singularPart μ).totalVariation =
      s.toJordanDecomposition.posPart.singularPart μ +
        s.toJordanDecomposition.negPart.singularPart μ := by
  have :
    (s.singularPart μ).toJordanDecomposition =
      ⟨s.toJordanDecomposition.posPart.singularPart μ,
        s.toJordanDecomposition.negPart.singularPart μ, singularPart_mutuallySingular s μ⟩ := by
    refine' JordanDecomposition.toSignedMeasure_injective _
    

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ JordanDecomposition.toSignedMeasure (toJordanDecomposition (singularPart s μ)) =
    JordanDecomposition.toSignedMeasure
      (JordanDecomposition.mk (Measure.singularPart (toJordanDecomposition s).posPart μ)
        (Measure.singularPart (toJordanDecomposition s).negPart μ)
        (_ :
          Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ
            Measure.singularPart (toJordanDecomposition s).negPart μ))

Next tactic:
rw [toSignedMeasure_toJordanDecomposition, singularPart, JordanDecomposition.toSignedMeasure]
theorem singularPart_totalVariation (s : SignedMeasure α) (μ : Measure α) :
    (s.singularPart μ).totalVariation =
      s.toJordanDecomposition.posPart.singularPart μ +
        s.toJordanDecomposition.negPart.singularPart μ := by
  have :
    (s.singularPart μ).toJordanDecomposition =
      ⟨s.toJordanDecomposition.posPart.singularPart μ,
        s.toJordanDecomposition.negPart.singularPart μ, singularPart_mutuallySingular s μ⟩ := by
    refine' JordanDecomposition.toSignedMeasure_injective _
    rw [toSignedMeasure_toJordanDecomposition, singularPart, JordanDecomposition.toSignedMeasure]
  · 

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
this :
  toJordanDecomposition (singularPart s μ) =
    JordanDecomposition.mk (Measure.singularPart (toJordanDecomposition s).posPart μ)
      (Measure.singularPart (toJordanDecomposition s).negPart μ)
      (_ :
        Measure.singularPart (toJordanDecomposition s).posPart μ ⟂ₘ
          Measure.singularPart (toJordanDecomposition s).negPart μ)
⊢ totalVariation (singularPart s μ) =
    Measure.singularPart (toJordanDecomposition s).posPart μ + Measure.singularPart (toJordanDecomposition s).negPart μ

Next tactic:
rw [totalVariation, this]
nonrec theorem mutuallySingular_singularPart (s : SignedMeasure α) (μ : Measure α) :
    singularPart s μ ⟂ᵥ μ.toENNRealVectorMeasure := by
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ singularPart s μ ⟂ᵥ toENNRealVectorMeasure μ

Next tactic:
rw [mutuallySingular_ennreal_iff, singularPart_totalVariation,
    VectorMeasure.ennrealToMeasure_toENNRealVectorMeasure]
nonrec theorem mutuallySingular_singularPart (s : SignedMeasure α) (μ : Measure α) :
    singularPart s μ ⟂ᵥ μ.toENNRealVectorMeasure := by
  rw [mutuallySingular_ennreal_iff, singularPart_totalVariation,
    VectorMeasure.ennrealToMeasure_toENNRealVectorMeasure]
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ Measure.singularPart (toJordanDecomposition s).posPart μ + Measure.singularPart (toJordanDecomposition s).negPart μ ⟂ₘ
    μ

Next tactic:
exact (mutuallySingular_singularPart _ _).add_left (mutuallySingular_singularPart _ _)
@[measurability]
theorem measurable_rnDeriv (s : SignedMeasure α) (μ : Measure α) : Measurable (rnDeriv s μ) := by
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ Measurable (rnDeriv s μ)

Next tactic:
rw [rnDeriv]
@[measurability]
theorem measurable_rnDeriv (s : SignedMeasure α) (μ : Measure α) : Measurable (rnDeriv s μ) := by
  rw [rnDeriv]
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ Measurable fun x =>
    ENNReal.toReal (Measure.rnDeriv (toJordanDecomposition s).posPart μ x) -
      ENNReal.toReal (Measure.rnDeriv (toJordanDecomposition s).negPart μ x)

Next tactic:
measurability
theorem integrable_rnDeriv (s : SignedMeasure α) (μ : Measure α) : Integrable (rnDeriv s μ) μ := by
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ Integrable (rnDeriv s μ)

Next tactic:
refine' Integrable.sub _ _
theorem integrable_rnDeriv (s : SignedMeasure α) (μ : Measure α) : Integrable (rnDeriv s μ) μ := by
  refine' Integrable.sub _ _ <;>
    · 

Proof state:
case refine'_1
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ Integrable fun x => ENNReal.toReal (Measure.rnDeriv (toJordanDecomposition s).posPart μ x)

Next tactic:
constructor
theorem integrable_rnDeriv (s : SignedMeasure α) (μ : Measure α) : Integrable (rnDeriv s μ) μ := by
  refine' Integrable.sub _ _ <;>
    · constructor
      · 

Proof state:
case refine'_1.left
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ AEStronglyMeasurable (fun x => ENNReal.toReal (Measure.rnDeriv (toJordanDecomposition s).posPart μ x)) μ

Next tactic:
apply Measurable.aestronglyMeasurable
theorem integrable_rnDeriv (s : SignedMeasure α) (μ : Measure α) : Integrable (rnDeriv s μ) μ := by
  refine' Integrable.sub _ _ <;>
    · constructor
      · apply Measurable.aestronglyMeasurable; 

Proof state:
case refine'_1.left.hf
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ Measurable fun x => ENNReal.toReal (Measure.rnDeriv (toJordanDecomposition s).posPart μ x)

Next tactic:
measurability
theorem integrable_rnDeriv (s : SignedMeasure α) (μ : Measure α) : Integrable (rnDeriv s μ) μ := by
  refine' Integrable.sub _ _ <;>
    · constructor
      · apply Measurable.aestronglyMeasurable; measurability
      

Proof state:
case refine'_1.right
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ HasFiniteIntegral fun x => ENNReal.toReal (Measure.rnDeriv (toJordanDecomposition s).posPart μ x)

Next tactic:
exact hasFiniteIntegral_toReal_of_lintegral_ne_top (lintegral_rnDeriv_lt_top _ μ).ne
theorem integrable_rnDeriv (s : SignedMeasure α) (μ : Measure α) : Integrable (rnDeriv s μ) μ := by
  refine' Integrable.sub _ _ <;>
    · 

Proof state:
case refine'_2
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
⊢ Integrable fun x => ENNReal.toReal (Measure.rnDeriv (toJordanDecomposition s).negPart μ x)

Next tactic:
constructor