l3lab/ntp-mathlib huggingface dataset:
theorem toJordanDecomposition_neg (s : SignedMeasure α) :
    (-s).toJordanDecomposition = -s.toJordanDecomposition := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
⊢ toJordanDecomposition (-s) = -toJordanDecomposition s

Next tactic:
apply toSignedMeasure_injective
theorem toJordanDecomposition_neg (s : SignedMeasure α) :
    (-s).toJordanDecomposition = -s.toJordanDecomposition := by
  apply toSignedMeasure_injective
  

Proof state:
case a
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
⊢ toSignedMeasure (toJordanDecomposition (-s)) = toSignedMeasure (-toJordanDecomposition s)

Next tactic:
simp [toSignedMeasure_neg]
theorem toJordanDecomposition_smul (s : SignedMeasure α) (r : ℝ≥0) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ≥0
⊢ toJordanDecomposition (r • s) = r • toJordanDecomposition s

Next tactic:
apply toSignedMeasure_injective
theorem toJordanDecomposition_smul (s : SignedMeasure α) (r : ℝ≥0) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  apply toSignedMeasure_injective
  

Proof state:
case a
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ≥0
⊢ toSignedMeasure (toJordanDecomposition (r • s)) = toSignedMeasure (r • toJordanDecomposition s)

Next tactic:
simp [toSignedMeasure_smul]
private theorem toJordanDecomposition_smul_real_nonneg (s : SignedMeasure α) (r : ℝ)
    (hr : 0 ≤ r) : (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : 0 ≤ r
⊢ toJordanDecomposition (r • s) = r • toJordanDecomposition s

Next tactic:
lift r to ℝ≥0 using hr
private theorem toJordanDecomposition_smul_real_nonneg (s : SignedMeasure α) (r : ℝ)
    (hr : 0 ≤ r) : (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  lift r to ℝ≥0 using hr
  

Proof state:
case intro
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ≥0
⊢ toJordanDecomposition (↑r • s) = ↑r • toJordanDecomposition s

Next tactic:
rw [JordanDecomposition.coe_smul, ← toJordanDecomposition_smul]
private theorem toJordanDecomposition_smul_real_nonneg (s : SignedMeasure α) (r : ℝ)
    (hr : 0 ≤ r) : (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  lift r to ℝ≥0 using hr
  rw [JordanDecomposition.coe_smul, ← toJordanDecomposition_smul]
  

Proof state:
case intro
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ≥0
⊢ toJordanDecomposition (↑r • s) = toJordanDecomposition (r • s)

Next tactic:
rfl
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
⊢ toJordanDecomposition (r • s) = r • toJordanDecomposition s

Next tactic:
by_cases hr : 0 ≤ r
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  by_cases hr : 0 ≤ r
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : 0 ≤ r
⊢ toJordanDecomposition (r • s) = r • toJordanDecomposition s

Next tactic:
exact toJordanDecomposition_smul_real_nonneg s r hr
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  by_cases hr : 0 ≤ r
  · exact toJordanDecomposition_smul_real_nonneg s r hr
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ toJordanDecomposition (r • s) = r • toJordanDecomposition s

Next tactic:
ext1
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  by_cases hr : 0 ≤ r
  · exact toJordanDecomposition_smul_real_nonneg s r hr
  · ext1
    · 

Proof state:
case neg.posPart
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ (toJordanDecomposition (r • s)).posPart = (r • toJordanDecomposition s).posPart

Next tactic:
rw [real_smul_posPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_posPart,
        toJordanDecomposition_smul_real_nonneg, ← smul_negPart, real_smul_nonneg]
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  by_cases hr : 0 ≤ r
  · exact toJordanDecomposition_smul_real_nonneg s r hr
  · ext1
    · rw [real_smul_posPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by 

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ r • s = -(-r • s)

Next tactic:
rw [neg_smul, neg_neg]
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  by_cases hr : 0 ≤ r
  · exact toJordanDecomposition_smul_real_nonneg s r hr
  · ext1
    · rw [real_smul_posPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_posPart,
        toJordanDecomposition_smul_real_nonneg, ← smul_negPart, real_smul_nonneg]
      

Proof state:
case neg.posPart.hr
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ 0 ≤ -r
case neg.posPart.hr α : Type u_1 β : Type u_2 inst✝ : MeasurableSpace α s : SignedMeasure α r : ℝ hr : ¬0 ≤ r ⊢ 0 ≤ -r

Next tactic:
all_goals exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  by_cases hr : 0 ≤ r
  · exact toJordanDecomposition_smul_real_nonneg s r hr
  · ext1
    · rw [real_smul_posPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_posPart,
        toJordanDecomposition_smul_real_nonneg, ← smul_negPart, real_smul_nonneg]
      all_goals 

Proof state:
case neg.posPart.hr
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ 0 ≤ -r

Next tactic:
exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  by_cases hr : 0 ≤ r
  · exact toJordanDecomposition_smul_real_nonneg s r hr
  · ext1
    · rw [real_smul_posPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_posPart,
        toJordanDecomposition_smul_real_nonneg, ← smul_negPart, real_smul_nonneg]
      all_goals exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
    · 

Proof state:
case neg.negPart
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ (toJordanDecomposition (r • s)).negPart = (r • toJordanDecomposition s).negPart

Next tactic:
rw [real_smul_negPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_negPart,
        toJordanDecomposition_smul_real_nonneg, ← smul_posPart, real_smul_nonneg]
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  by_cases hr : 0 ≤ r
  · exact toJordanDecomposition_smul_real_nonneg s r hr
  · ext1
    · rw [real_smul_posPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_posPart,
        toJordanDecomposition_smul_real_nonneg, ← smul_negPart, real_smul_nonneg]
      all_goals exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
    · rw [real_smul_negPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by 

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ r • s = -(-r • s)

Next tactic:
rw [neg_smul, neg_neg]
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  by_cases hr : 0 ≤ r
  · exact toJordanDecomposition_smul_real_nonneg s r hr
  · ext1
    · rw [real_smul_posPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_posPart,
        toJordanDecomposition_smul_real_nonneg, ← smul_negPart, real_smul_nonneg]
      all_goals exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
    · rw [real_smul_negPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_negPart,
        toJordanDecomposition_smul_real_nonneg, ← smul_posPart, real_smul_nonneg]
      

Proof state:
case neg.negPart.hr
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ 0 ≤ -r
case neg.negPart.hr α : Type u_1 β : Type u_2 inst✝ : MeasurableSpace α s : SignedMeasure α r : ℝ hr : ¬0 ≤ r ⊢ 0 ≤ -r

Next tactic:
all_goals exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
theorem toJordanDecomposition_smul_real (s : SignedMeasure α) (r : ℝ) :
    (r • s).toJordanDecomposition = r • s.toJordanDecomposition := by
  by_cases hr : 0 ≤ r
  · exact toJordanDecomposition_smul_real_nonneg s r hr
  · ext1
    · rw [real_smul_posPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_posPart,
        toJordanDecomposition_smul_real_nonneg, ← smul_negPart, real_smul_nonneg]
      all_goals exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
    · rw [real_smul_negPart_neg _ _ (not_le.1 hr),
        show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_negPart,
        toJordanDecomposition_smul_real_nonneg, ← smul_posPart, real_smul_nonneg]
      all_goals 

Proof state:
case neg.negPart.hr
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ 0 ≤ -r

Next tactic:
exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
theorem toJordanDecomposition_eq {s : SignedMeasure α} {j : JordanDecomposition α}
    (h : s = j.toSignedMeasure) : s.toJordanDecomposition = j := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
j : JordanDecomposition α
h : s = toSignedMeasure j
⊢ toJordanDecomposition s = j

Next tactic:
rw [h, toJordanDecomposition_toSignedMeasure]
theorem totalVariation_zero : (0 : SignedMeasure α).totalVariation = 0 := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
⊢ totalVariation 0 = 0

Next tactic:
simp [totalVariation, toJordanDecomposition_zero]
theorem totalVariation_neg (s : SignedMeasure α) : (-s).totalVariation = s.totalVariation := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
⊢ totalVariation (-s) = totalVariation s

Next tactic:
simp [totalVariation, toJordanDecomposition_neg, add_comm]
theorem null_of_totalVariation_zero (s : SignedMeasure α) {i : Set α}
    (hs : s.totalVariation i = 0) : s i = 0 := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(totalVariation s) i = 0
⊢ ↑s i = 0

Next tactic:
rw [totalVariation, Measure.coe_add, Pi.add_apply, add_eq_zero_iff] at hs
theorem null_of_totalVariation_zero (s : SignedMeasure α) {i : Set α}
    (hs : s.totalVariation i = 0) : s i = 0 := by
  rw [totalVariation, Measure.coe_add, Pi.add_apply, add_eq_zero_iff] at hs
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(toJordanDecomposition s).posPart i = 0 ∧ ↑↑(toJordanDecomposition s).negPart i = 0
⊢ ↑s i = 0

Next tactic:
rw [← toSignedMeasure_toJordanDecomposition s, toSignedMeasure, VectorMeasure.coe_sub,
    Pi.sub_apply, Measure.toSignedMeasure_apply, Measure.toSignedMeasure_apply]
theorem null_of_totalVariation_zero (s : SignedMeasure α) {i : Set α}
    (hs : s.totalVariation i = 0) : s i = 0 := by
  rw [totalVariation, Measure.coe_add, Pi.add_apply, add_eq_zero_iff] at hs
  rw [← toSignedMeasure_toJordanDecomposition s, toSignedMeasure, VectorMeasure.coe_sub,
    Pi.sub_apply, Measure.toSignedMeasure_apply, Measure.toSignedMeasure_apply]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(toJordanDecomposition s).posPart i = 0 ∧ ↑↑(toJordanDecomposition s).negPart i = 0
⊢ ((if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).posPart i) else 0) -
      if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).negPart i) else 0) =
    0

Next tactic:
by_cases hi : MeasurableSet i
theorem null_of_totalVariation_zero (s : SignedMeasure α) {i : Set α}
    (hs : s.totalVariation i = 0) : s i = 0 := by
  rw [totalVariation, Measure.coe_add, Pi.add_apply, add_eq_zero_iff] at hs
  rw [← toSignedMeasure_toJordanDecomposition s, toSignedMeasure, VectorMeasure.coe_sub,
    Pi.sub_apply, Measure.toSignedMeasure_apply, Measure.toSignedMeasure_apply]
  by_cases hi : MeasurableSet i
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(toJordanDecomposition s).posPart i = 0 ∧ ↑↑(toJordanDecomposition s).negPart i = 0
hi : MeasurableSet i
⊢ ((if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).posPart i) else 0) -
      if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).negPart i) else 0) =
    0

Next tactic:
rw [if_pos hi, if_pos hi]
theorem null_of_totalVariation_zero (s : SignedMeasure α) {i : Set α}
    (hs : s.totalVariation i = 0) : s i = 0 := by
  rw [totalVariation, Measure.coe_add, Pi.add_apply, add_eq_zero_iff] at hs
  rw [← toSignedMeasure_toJordanDecomposition s, toSignedMeasure, VectorMeasure.coe_sub,
    Pi.sub_apply, Measure.toSignedMeasure_apply, Measure.toSignedMeasure_apply]
  by_cases hi : MeasurableSet i
  · rw [if_pos hi, if_pos hi]; 

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(toJordanDecomposition s).posPart i = 0 ∧ ↑↑(toJordanDecomposition s).negPart i = 0
hi : MeasurableSet i
⊢ ENNReal.toReal (↑↑(toJordanDecomposition s).posPart i) - ENNReal.toReal (↑↑(toJordanDecomposition s).negPart i) = 0

Next tactic:
simp [hs.1, hs.2]
theorem null_of_totalVariation_zero (s : SignedMeasure α) {i : Set α}
    (hs : s.totalVariation i = 0) : s i = 0 := by
  rw [totalVariation, Measure.coe_add, Pi.add_apply, add_eq_zero_iff] at hs
  rw [← toSignedMeasure_toJordanDecomposition s, toSignedMeasure, VectorMeasure.coe_sub,
    Pi.sub_apply, Measure.toSignedMeasure_apply, Measure.toSignedMeasure_apply]
  by_cases hi : MeasurableSet i
  · rw [if_pos hi, if_pos hi]; simp [hs.1, hs.2]
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(toJordanDecomposition s).posPart i = 0 ∧ ↑↑(toJordanDecomposition s).negPart i = 0
hi : ¬MeasurableSet i
⊢ ((if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).posPart i) else 0) -
      if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).negPart i) else 0) =
    0

Next tactic:
simp [if_neg hi]
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
⊢ s ≪ᵥ μ ↔ totalVariation s ≪ VectorMeasure.ennrealToMeasure μ

Next tactic:
constructor
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure := by
  constructor <;> 

Proof state:
case mp
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
⊢ s ≪ᵥ μ → totalVariation s ≪ VectorMeasure.ennrealToMeasure μ

Next tactic:
intro h
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure := by
  constructor <;> 

Proof state:
case mpr
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
⊢ totalVariation s ≪ VectorMeasure.ennrealToMeasure μ → s ≪ᵥ μ

Next tactic:
intro h
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure := by
  constructor <;> intro h
  · 

Proof state:
case mp
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
h : s ≪ᵥ μ
⊢ totalVariation s ≪ VectorMeasure.ennrealToMeasure μ

Next tactic:
refine' Measure.AbsolutelyContinuous.mk fun S hS₁ hS₂ => _
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure := by
  constructor <;> intro h
  · refine' Measure.AbsolutelyContinuous.mk fun S hS₁ hS₂ => _
    

Proof state:
case mp
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
h : s ≪ᵥ μ
S : Set α
hS₁ : MeasurableSet S
hS₂ : ↑↑(VectorMeasure.ennrealToMeasure μ) S = 0
⊢ ↑↑(totalVariation s) S = 0

Next tactic:
obtain ⟨i, hi₁, hi₂, hi₃, hpos, hneg⟩ := s.toJordanDecomposition_spec
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure := by
  constructor <;> intro h
  · refine' Measure.AbsolutelyContinuous.mk fun S hS₁ hS₂ => _
    obtain ⟨i, hi₁, hi₂, hi₃, hpos, hneg⟩ := s.toJordanDecomposition_spec
    

Proof state:
case mp.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
h : s ≪ᵥ μ
S : Set α
hS₁ : MeasurableSet S
hS₂ : ↑↑(VectorMeasure.ennrealToMeasure μ) S = 0
i : Set α
hi₁ : MeasurableSet i
hi₂ : VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i
hi₃ : VectorMeasure.restrict s iᶜ ≤ VectorMeasure.restrict 0 iᶜ
hpos : (toJordanDecomposition s).posPart = toMeasureOfZeroLE s i hi₁ hi₂
hneg : (toJordanDecomposition s).negPart = toMeasureOfLEZero s iᶜ (_ : MeasurableSet iᶜ) hi₃
⊢ ↑↑(totalVariation s) S = 0

Next tactic:
rw [totalVariation, Measure.add_apply, hpos, hneg, toMeasureOfZeroLE_apply _ _ _ hS₁,
      toMeasureOfLEZero_apply _ _ _ hS₁]
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure := by
  constructor <;> intro h
  · refine' Measure.AbsolutelyContinuous.mk fun S hS₁ hS₂ => _
    obtain ⟨i, hi₁, hi₂, hi₃, hpos, hneg⟩ := s.toJordanDecomposition_spec
    rw [totalVariation, Measure.add_apply, hpos, hneg, toMeasureOfZeroLE_apply _ _ _ hS₁,
      toMeasureOfLEZero_apply _ _ _ hS₁]
    

Proof state:
case mp.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
h : s ≪ᵥ μ
S : Set α
hS₁ : MeasurableSet S
hS₂ : ↑↑(VectorMeasure.ennrealToMeasure μ) S = 0
i : Set α
hi₁ : MeasurableSet i
hi₂ : VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i
hi₃ : VectorMeasure.restrict s iᶜ ≤ VectorMeasure.restrict 0 iᶜ
hpos : (toJordanDecomposition s).posPart = toMeasureOfZeroLE s i hi₁ hi₂
hneg : (toJordanDecomposition s).negPart = toMeasureOfLEZero s iᶜ (_ : MeasurableSet iᶜ) hi₃
⊢ ↑{ val := ↑s (i ∩ S), property := (_ : 0 ≤ ↑s (i ∩ S)) } +
      ↑{ val := -↑s (iᶜ ∩ S), property := (_ : 0 ≤ -↑s (iᶜ ∩ S)) } =
    0

Next tactic:
rw [← VectorMeasure.AbsolutelyContinuous.ennrealToMeasure] at h
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure := by
  constructor <;> intro h
  · refine' Measure.AbsolutelyContinuous.mk fun S hS₁ hS₂ => _
    obtain ⟨i, hi₁, hi₂, hi₃, hpos, hneg⟩ := s.toJordanDecomposition_spec
    rw [totalVariation, Measure.add_apply, hpos, hneg, toMeasureOfZeroLE_apply _ _ _ hS₁,
      toMeasureOfLEZero_apply _ _ _ hS₁]
    rw [← VectorMeasure.AbsolutelyContinuous.ennrealToMeasure] at h
    -- Porting note: added `← NNReal.eq_iff`
    

Proof state:
case mp.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
h : ∀ ⦃s_1 : Set α⦄, ↑↑(VectorMeasure.ennrealToMeasure μ) s_1 = 0 → ↑s s_1 = 0
S : Set α
hS₁ : MeasurableSet S
hS₂ : ↑↑(VectorMeasure.ennrealToMeasure μ) S = 0
i : Set α
hi₁ : MeasurableSet i
hi₂ : VectorMeasure.restrict 0 i ≤ VectorMeasure.restrict s i
hi₃ : VectorMeasure.restrict s iᶜ ≤ VectorMeasure.restrict 0 iᶜ
hpos : (toJordanDecomposition s).posPart = toMeasureOfZeroLE s i hi₁ hi₂
hneg : (toJordanDecomposition s).negPart = toMeasureOfLEZero s iᶜ (_ : MeasurableSet iᶜ) hi₃
⊢ ↑{ val := ↑s (i ∩ S), property := (_ : 0 ≤ ↑s (i ∩ S)) } +
      ↑{ val := -↑s (iᶜ ∩ S), property := (_ : 0 ≤ -↑s (iᶜ ∩ S)) } =
    0

Next tactic:
simp [h (measure_mono_null (i.inter_subset_right S) hS₂),
      h (measure_mono_null (iᶜ.inter_subset_right S) hS₂), ← NNReal.eq_iff]
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure := by
  constructor <;> intro h
  · refine' Measure.AbsolutelyContinuous.mk fun S hS₁ hS₂ => _
    obtain ⟨i, hi₁, hi₂, hi₃, hpos, hneg⟩ := s.toJordanDecomposition_spec
    rw [totalVariation, Measure.add_apply, hpos, hneg, toMeasureOfZeroLE_apply _ _ _ hS₁,
      toMeasureOfLEZero_apply _ _ _ hS₁]
    rw [← VectorMeasure.AbsolutelyContinuous.ennrealToMeasure] at h
    -- Porting note: added `← NNReal.eq_iff`
    simp [h (measure_mono_null (i.inter_subset_right S) hS₂),
      h (measure_mono_null (iᶜ.inter_subset_right S) hS₂), ← NNReal.eq_iff]
  · 

Proof state:
case mpr
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
h : totalVariation s ≪ VectorMeasure.ennrealToMeasure μ
⊢ s ≪ᵥ μ

Next tactic:
refine' VectorMeasure.AbsolutelyContinuous.mk fun S hS₁ hS₂ => _
theorem absolutelyContinuous_ennreal_iff (s : SignedMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    s ≪ᵥ μ ↔ s.totalVariation ≪ μ.ennrealToMeasure := by
  constructor <;> intro h
  · refine' Measure.AbsolutelyContinuous.mk fun S hS₁ hS₂ => _
    obtain ⟨i, hi₁, hi₂, hi₃, hpos, hneg⟩ := s.toJordanDecomposition_spec
    rw [totalVariation, Measure.add_apply, hpos, hneg, toMeasureOfZeroLE_apply _ _ _ hS₁,
      toMeasureOfLEZero_apply _ _ _ hS₁]
    rw [← VectorMeasure.AbsolutelyContinuous.ennrealToMeasure] at h
    -- Porting note: added `← NNReal.eq_iff`
    simp [h (measure_mono_null (i.inter_subset_right S) hS₂),
      h (measure_mono_null (iᶜ.inter_subset_right S) hS₂), ← NNReal.eq_iff]
  · refine' VectorMeasure.AbsolutelyContinuous.mk fun S hS₁ hS₂ => _
    

Proof state:
case mpr
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : VectorMeasure α ℝ≥0∞
h : totalVariation s ≪ VectorMeasure.ennrealToMeasure μ
S : Set α
hS₁ : MeasurableSet S
hS₂ : ↑μ S = 0
⊢ ↑s S = 0

Next tactic:
rw [← VectorMeasure.ennrealToMeasure_apply hS₁] at hS₂