measure_theory.measure.mutually_singular ⟷ Mathlib.MeasureTheory.Measure.MutuallySingular

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,7 +3,7 @@ Copyright (c) 2021 Kexing Ying. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kexing Ying, Yury Kudryashov
 -/
-import Mathbin.MeasureTheory.Measure.MeasureSpace
+import MeasureTheory.Measure.MeasureSpace
 
 #align_import measure_theory.measure.mutually_singular from "leanprover-community/mathlib"@"781cb2eed038c4caf53bdbd8d20a95e5822d77df"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,14 +2,11 @@
 Copyright (c) 2021 Kexing Ying. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kexing Ying, Yury Kudryashov
-
-! This file was ported from Lean 3 source module measure_theory.measure.mutually_singular
-! leanprover-community/mathlib commit 781cb2eed038c4caf53bdbd8d20a95e5822d77df
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.MeasureTheory.Measure.MeasureSpace
 
+#align_import measure_theory.measure.mutually_singular from "leanprover-community/mathlib"@"781cb2eed038c4caf53bdbd8d20a95e5822d77df"
+
 /-! # Mutually singular measures
 
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -48,11 +48,11 @@ def MutuallySingular {m0 : MeasurableSpace α} (μ ν : Measure α) : Prop :=
 #align measure_theory.measure.mutually_singular MeasureTheory.Measure.MutuallySingular
 -/
 
--- mathport name: measure.mutually_singular
 scoped[MeasureTheory] infixl:60 " ⟂ₘ " => MeasureTheory.Measure.MutuallySingular
 
 namespace MutuallySingular
 
+#print MeasureTheory.Measure.MutuallySingular.mk /-
 theorem mk {s t : Set α} (hs : μ s = 0) (ht : ν t = 0) (hst : univ ⊆ s ∪ t) :
     MutuallySingular μ ν :=
   by
@@ -60,6 +60,7 @@ theorem mk {s t : Set α} (hs : μ s = 0) (ht : ν t = 0) (hst : univ ⊆ s ∪
   refine' measure_mono_null (fun x hx => (hst trivial).resolve_left fun hxs => hx _) ht
   exact subset_to_measurable _ _ hxs
 #align measure_theory.measure.mutually_singular.mk MeasureTheory.Measure.MutuallySingular.mk
+-/
 
 #print MeasureTheory.Measure.MutuallySingular.zero_right /-
 @[simp]
@@ -148,13 +149,17 @@ theorem add_right (h₁ : μ ⟂ₘ ν₁) (h₂ : μ ⟂ₘ ν₂) : μ ⟂ₘ
 #align measure_theory.measure.mutually_singular.add_right MeasureTheory.Measure.MutuallySingular.add_right
 -/
 
+#print MeasureTheory.Measure.MutuallySingular.smul /-
 theorem smul (r : ℝ≥0∞) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
   h.mono_ac (AbsolutelyContinuous.rfl.smul r) AbsolutelyContinuous.rfl
 #align measure_theory.measure.mutually_singular.smul MeasureTheory.Measure.MutuallySingular.smul
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.smul_nnreal /-
 theorem smul_nnreal (r : ℝ≥0) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
   h.smul r
 #align measure_theory.measure.mutually_singular.smul_nnreal MeasureTheory.Measure.MutuallySingular.smul_nnreal
+-/
 
 end MutuallySingular
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -32,7 +32,7 @@ measure, mutually singular
 
 open Set
 
-open MeasureTheory NNReal ENNReal
+open scoped MeasureTheory NNReal ENNReal
 
 namespace MeasureTheory
 
@@ -96,9 +96,11 @@ theorem mono_ac (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≪ μ₁) (hν : ν₂ 
 #align measure_theory.measure.mutually_singular.mono_ac MeasureTheory.Measure.MutuallySingular.mono_ac
 -/
 
+#print MeasureTheory.Measure.MutuallySingular.mono /-
 theorem mono (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≤ μ₁) (hν : ν₂ ≤ ν₁) : μ₂ ⟂ₘ ν₂ :=
   h.mono_ac hμ.AbsolutelyContinuous hν.AbsolutelyContinuous
 #align measure_theory.measure.mutually_singular.mono MeasureTheory.Measure.MutuallySingular.mono
+-/
 
 #print MeasureTheory.Measure.MutuallySingular.sum_left /-
 @[simp]

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -53,12 +53,6 @@ scoped[MeasureTheory] infixl:60 " ⟂ₘ " => MeasureTheory.Measure.MutuallySing
 
 namespace MutuallySingular
 
-/- warning: measure_theory.measure.mutually_singular.mk -> MeasureTheory.Measure.MutuallySingular.mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} {s : Set.{u1} α} {t : Set.{u1} α}, (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m0) (fun (_x : MeasureTheory.Measure.{u1} α m0) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m0) μ s) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m0) (fun (_x : MeasureTheory.Measure.{u1} α m0) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m0) ν t) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.univ.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t)) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ ν)
-but is expected to have type
-  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} {s : Set.{u1} α} {t : Set.{u1} α}, (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m0 μ) s) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m0 ν) t) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.univ.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t)) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ ν)
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.mutually_singular.mk MeasureTheory.Measure.MutuallySingular.mkₓ'. -/
 theorem mk {s t : Set α} (hs : μ s = 0) (ht : ν t = 0) (hst : univ ⊆ s ∪ t) :
     MutuallySingular μ ν :=
   by
@@ -102,12 +96,6 @@ theorem mono_ac (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≪ μ₁) (hν : ν₂ 
 #align measure_theory.measure.mutually_singular.mono_ac MeasureTheory.Measure.MutuallySingular.mono_ac
 -/
 
-/- warning: measure_theory.measure.mutually_singular.mono -> MeasureTheory.Measure.MutuallySingular.mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ₁ : MeasureTheory.Measure.{u1} α m0} {μ₂ : MeasureTheory.Measure.{u1} α m0} {ν₁ : MeasureTheory.Measure.{u1} α m0} {ν₂ : MeasureTheory.Measure.{u1} α m0}, (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ₁ ν₁) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m0) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m0) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instPartialOrder.{u1} α m0))) μ₂ μ₁) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m0) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m0) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instPartialOrder.{u1} α m0))) ν₂ ν₁) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ₂ ν₂)
-but is expected to have type
-  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ₁ : MeasureTheory.Measure.{u1} α m0} {μ₂ : MeasureTheory.Measure.{u1} α m0} {ν₁ : MeasureTheory.Measure.{u1} α m0} {ν₂ : MeasureTheory.Measure.{u1} α m0}, (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ₁ ν₁) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m0) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m0) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instPartialOrder.{u1} α m0))) μ₂ μ₁) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m0) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m0) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instPartialOrder.{u1} α m0))) ν₂ ν₁) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ₂ ν₂)
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.mutually_singular.mono MeasureTheory.Measure.MutuallySingular.monoₓ'. -/
 theorem mono (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≤ μ₁) (hν : ν₂ ≤ ν₁) : μ₂ ⟂ₘ ν₂ :=
   h.mono_ac hμ.AbsolutelyContinuous hν.AbsolutelyContinuous
 #align measure_theory.measure.mutually_singular.mono MeasureTheory.Measure.MutuallySingular.mono
@@ -158,22 +146,10 @@ theorem add_right (h₁ : μ ⟂ₘ ν₁) (h₂ : μ ⟂ₘ ν₂) : μ ⟂ₘ
 #align measure_theory.measure.mutually_singular.add_right MeasureTheory.Measure.MutuallySingular.add_right
 -/
 
-/- warning: measure_theory.measure.mutually_singular.smul -> MeasureTheory.Measure.MutuallySingular.smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} (r : ENNReal), (MeasureTheory.Measure.MutuallySingular.{u1} α m0 ν μ) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 (SMul.smul.{0, u1} ENNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instSMul.{u1, 0} α ENNReal (SMulZeroClass.toHasSmul.{0, 0} ENNReal ENNReal (AddZeroClass.toHasZero.{0} ENNReal (AddMonoid.toAddZeroClass.{0} ENNReal (AddCommMonoid.toAddMonoid.{0} ENNReal (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) (SMulWithZero.toSmulZeroClass.{0, 0} ENNReal ENNReal (MulZeroClass.toHasZero.{0} ENNReal (MulZeroOneClass.toMulZeroClass.{0} ENNReal (MonoidWithZero.toMulZeroOneClass.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))) (AddZeroClass.toHasZero.{0} ENNReal (AddMonoid.toAddZeroClass.{0} ENNReal (AddCommMonoid.toAddMonoid.{0} ENNReal (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) (MulActionWithZero.toSMulWithZero.{0, 0} ENNReal ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (AddZeroClass.toHasZero.{0} ENNReal (AddMonoid.toAddZeroClass.{0} ENNReal (AddCommMonoid.toAddMonoid.{0} ENNReal (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) (Module.toMulActionWithZero.{0, 0} ENNReal ENNReal (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))) (Algebra.toModule.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))) (IsScalarTower.right.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) m0) r ν) μ)
-but is expected to have type
-  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} (r : ENNReal), (MeasureTheory.Measure.MutuallySingular.{u1} α m0 ν μ) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 (HSMul.hSMul.{0, u1, u1} ENNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.{u1} α m0) (instHSMul.{0, u1} ENNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instSMul.{u1, 0} α ENNReal (Algebra.toSMul.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (IsScalarTower.right.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal) (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) m0)) r ν) μ)
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.mutually_singular.smul MeasureTheory.Measure.MutuallySingular.smulₓ'. -/
 theorem smul (r : ℝ≥0∞) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
   h.mono_ac (AbsolutelyContinuous.rfl.smul r) AbsolutelyContinuous.rfl
 #align measure_theory.measure.mutually_singular.smul MeasureTheory.Measure.MutuallySingular.smul
 
-/- warning: measure_theory.measure.mutually_singular.smul_nnreal -> MeasureTheory.Measure.MutuallySingular.smul_nnreal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} (r : NNReal), (MeasureTheory.Measure.MutuallySingular.{u1} α m0 ν μ) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 (SMul.smul.{0, u1} NNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instSMul.{u1, 0} α NNReal (MulAction.toHasSmul.{0, 0} NNReal ENNReal (MonoidWithZero.toMonoid.{0} NNReal (Semiring.toMonoidWithZero.{0} NNReal NNReal.semiring)) (ENNReal.mulAction.{0} ENNReal (Monoid.toMulAction.{0} ENNReal (MonoidWithZero.toMonoid.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (ENNReal.isScalarTower.{0, 0} ENNReal ENNReal (Monoid.toMulAction.{0} ENNReal (MonoidWithZero.toMonoid.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))) (Monoid.toMulAction.{0} ENNReal (MonoidWithZero.toMonoid.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))) (Mul.toSMul.{0} ENNReal (Distrib.toHasMul.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (IsScalarTower.right.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))) m0) r ν) μ)
-but is expected to have type
-  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} (r : NNReal), (MeasureTheory.Measure.MutuallySingular.{u1} α m0 ν μ) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 (HSMul.hSMul.{0, u1, u1} NNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.{u1} α m0) (instHSMul.{0, u1} NNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instSMul.{u1, 0} α NNReal (Algebra.toSMul.{0, 0} NNReal ENNReal instNNRealCommSemiring (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (ENNReal.instAlgebraNNRealInstNNRealCommSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))) (ENNReal.instIsScalarTowerNNRealToSMulToMonoidToMonoidWithZeroInstNNRealSemiringInstMulActionNNRealToMonoidToMonoidWithZeroInstNNRealSemiringToSMulInstMulActionNNRealToMonoidToMonoidWithZeroInstNNRealSemiring.{0, 0} ENNReal ENNReal (MulActionWithZero.toMulAction.{0, 0} ENNReal ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))) instENNRealZero (MonoidWithZero.toMulActionWithZero.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))) (MulActionWithZero.toMulAction.{0, 0} ENNReal ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))) instENNRealZero (MonoidWithZero.toMulActionWithZero.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))) (Algebra.toSMul.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (IsScalarTower.right.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal) (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))) m0)) r ν) μ)
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.mutually_singular.smul_nnreal MeasureTheory.Measure.MutuallySingular.smul_nnrealₓ'. -/
 theorem smul_nnreal (r : ℝ≥0) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
   h.smul r
 #align measure_theory.measure.mutually_singular.smul_nnreal MeasureTheory.Measure.MutuallySingular.smul_nnreal

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

@@ -102,11 +102,15 @@ theorem mono_ac (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≪ μ₁) (hν : ν₂ 
 #align measure_theory.measure.mutually_singular.mono_ac MeasureTheory.Measure.MutuallySingular.mono_ac
 -/
 
-#print MeasureTheory.Measure.MutuallySingular.mono /-
+/- warning: measure_theory.measure.mutually_singular.mono -> MeasureTheory.Measure.MutuallySingular.mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ₁ : MeasureTheory.Measure.{u1} α m0} {μ₂ : MeasureTheory.Measure.{u1} α m0} {ν₁ : MeasureTheory.Measure.{u1} α m0} {ν₂ : MeasureTheory.Measure.{u1} α m0}, (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ₁ ν₁) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m0) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m0) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instPartialOrder.{u1} α m0))) μ₂ μ₁) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m0) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m0) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instPartialOrder.{u1} α m0))) ν₂ ν₁) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ₂ ν₂)
+but is expected to have type
+  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ₁ : MeasureTheory.Measure.{u1} α m0} {μ₂ : MeasureTheory.Measure.{u1} α m0} {ν₁ : MeasureTheory.Measure.{u1} α m0} {ν₂ : MeasureTheory.Measure.{u1} α m0}, (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ₁ ν₁) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m0) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m0) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instPartialOrder.{u1} α m0))) μ₂ μ₁) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m0) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m0) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instPartialOrder.{u1} α m0))) ν₂ ν₁) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ₂ ν₂)
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.mutually_singular.mono MeasureTheory.Measure.MutuallySingular.monoₓ'. -/
 theorem mono (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≤ μ₁) (hν : ν₂ ≤ ν₁) : μ₂ ⟂ₘ ν₂ :=
   h.mono_ac hμ.AbsolutelyContinuous hν.AbsolutelyContinuous
 #align measure_theory.measure.mutually_singular.mono MeasureTheory.Measure.MutuallySingular.mono
--/
 
 #print MeasureTheory.Measure.MutuallySingular.sum_left /-
 @[simp]

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

@@ -114,8 +114,8 @@ theorem sum_left {ι : Type _} [Countable ι] {μ : ι → Measure α} : sum μ
   by
   refine' ⟨fun h i => h.mono (le_sum _ _) le_rfl, fun H => _⟩
   choose s hsm hsμ hsν using H
-  refine' ⟨⋂ i, s i, MeasurableSet.interᵢ hsm, _, _⟩
-  · rw [sum_apply _ (MeasurableSet.interᵢ hsm), ENNReal.tsum_eq_zero]
+  refine' ⟨⋂ i, s i, MeasurableSet.iInter hsm, _, _⟩
+  · rw [sum_apply _ (MeasurableSet.iInter hsm), ENNReal.tsum_eq_zero]
     exact fun i => measure_mono_null (Inter_subset _ _) (hsμ i)
   · rwa [compl_Inter, measure_Union_null_iff]
 #align measure_theory.measure.mutually_singular.sum_left MeasureTheory.Measure.MutuallySingular.sum_left

mathlib commit https://github.com/leanprover-community/mathlib/commit/2f8347015b12b0864dfaf366ec4909eb70c78740

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kexing Ying, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module measure_theory.measure.mutually_singular
-! leanprover-community/mathlib commit 70a4f2197832bceab57d7f41379b2592d1110570
+! leanprover-community/mathlib commit 781cb2eed038c4caf53bdbd8d20a95e5822d77df
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -12,6 +12,9 @@ import Mathbin.MeasureTheory.Measure.MeasureSpace
 
 /-! # Mutually singular measures
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Two measures `μ`, `ν` are said to be mutually singular (`measure_theory.measure.mutually_singular`,
 localized notation `μ ⟂ₘ ν`) if there exists a measurable set `s` such that `μ s = 0` and
 `ν sᶜ = 0`. The measurability of `s` is an unnecessary assumption (see

mathlib commit https://github.com/leanprover-community/mathlib/commit/28b2a92f2996d28e580450863c130955de0ed398

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kexing Ying, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module measure_theory.measure.mutually_singular
-! leanprover-community/mathlib commit 781cb2eed038c4caf53bdbd8d20a95e5822d77df
+! leanprover-community/mathlib commit 70a4f2197832bceab57d7f41379b2592d1110570
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -12,9 +12,6 @@ import Mathbin.MeasureTheory.Measure.MeasureSpace
 
 /-! # Mutually singular measures
 
-> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
-> Any changes to this file require a corresponding PR to mathlib4.
-
 Two measures `μ`, `ν` are said to be mutually singular (`measure_theory.measure.mutually_singular`,
 localized notation `μ ⟂ₘ ν`) if there exists a measurable set `s` such that `μ s = 0` and
 `ν sᶜ = 0`. The measurability of `s` is an unnecessary assumption (see

mathlib commit https://github.com/leanprover-community/mathlib/commit/2f8347015b12b0864dfaf366ec4909eb70c78740

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kexing Ying, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module measure_theory.measure.mutually_singular
-! leanprover-community/mathlib commit 70a4f2197832bceab57d7f41379b2592d1110570
+! leanprover-community/mathlib commit 781cb2eed038c4caf53bdbd8d20a95e5822d77df
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -12,6 +12,9 @@ import Mathbin.MeasureTheory.Measure.MeasureSpace
 
 /-! # Mutually singular measures
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Two measures `μ`, `ν` are said to be mutually singular (`measure_theory.measure.mutually_singular`,
 localized notation `μ ⟂ₘ ν`) if there exists a measurable set `s` such that `μ s = 0` and
 `ν sᶜ = 0`. The measurability of `s` is an unnecessary assumption (see

mathlib commit https://github.com/leanprover-community/mathlib/commit/cc5dd6244981976cc9da7afc4eee5682b037a013

@@ -37,17 +37,25 @@ namespace Measure
 
 variable {α : Type _} {m0 : MeasurableSpace α} {μ μ₁ μ₂ ν ν₁ ν₂ : Measure α}
 
+#print MeasureTheory.Measure.MutuallySingular /-
 /-- Two measures `μ`, `ν` are said to be mutually singular if there exists a measurable set `s`
 such that `μ s = 0` and `ν sᶜ = 0`. -/
 def MutuallySingular {m0 : MeasurableSpace α} (μ ν : Measure α) : Prop :=
   ∃ s : Set α, MeasurableSet s ∧ μ s = 0 ∧ ν (sᶜ) = 0
 #align measure_theory.measure.mutually_singular MeasureTheory.Measure.MutuallySingular
+-/
 
 -- mathport name: measure.mutually_singular
 scoped[MeasureTheory] infixl:60 " ⟂ₘ " => MeasureTheory.Measure.MutuallySingular
 
 namespace MutuallySingular
 
+/- warning: measure_theory.measure.mutually_singular.mk -> MeasureTheory.Measure.MutuallySingular.mk is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} {s : Set.{u1} α} {t : Set.{u1} α}, (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m0) (fun (_x : MeasureTheory.Measure.{u1} α m0) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m0) μ s) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m0) (fun (_x : MeasureTheory.Measure.{u1} α m0) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m0) ν t) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero)))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.univ.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t)) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ ν)
+but is expected to have type
+  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} {s : Set.{u1} α} {t : Set.{u1} α}, (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m0 μ) s) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m0 ν) t) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero))) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) (Set.univ.{u1} α) (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t)) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 μ ν)
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.mutually_singular.mk MeasureTheory.Measure.MutuallySingular.mkₓ'. -/
 theorem mk {s t : Set α} (hs : μ s = 0) (ht : ν t = 0) (hst : univ ⊆ s ∪ t) :
     MutuallySingular μ ν :=
   by
@@ -56,35 +64,48 @@ theorem mk {s t : Set α} (hs : μ s = 0) (ht : ν t = 0) (hst : univ ⊆ s ∪
   exact subset_to_measurable _ _ hxs
 #align measure_theory.measure.mutually_singular.mk MeasureTheory.Measure.MutuallySingular.mk
 
+#print MeasureTheory.Measure.MutuallySingular.zero_right /-
 @[simp]
 theorem zero_right : μ ⟂ₘ 0 :=
   ⟨∅, MeasurableSet.empty, measure_empty, rfl⟩
 #align measure_theory.measure.mutually_singular.zero_right MeasureTheory.Measure.MutuallySingular.zero_right
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.symm /-
 @[symm]
 theorem symm (h : ν ⟂ₘ μ) : μ ⟂ₘ ν :=
   let ⟨i, hi, his, hit⟩ := h
   ⟨iᶜ, hi.compl, hit, (compl_compl i).symm ▸ his⟩
 #align measure_theory.measure.mutually_singular.symm MeasureTheory.Measure.MutuallySingular.symm
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.comm /-
 theorem comm : μ ⟂ₘ ν ↔ ν ⟂ₘ μ :=
   ⟨fun h => h.symm, fun h => h.symm⟩
 #align measure_theory.measure.mutually_singular.comm MeasureTheory.Measure.MutuallySingular.comm
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.zero_left /-
 @[simp]
 theorem zero_left : 0 ⟂ₘ μ :=
   zero_right.symm
 #align measure_theory.measure.mutually_singular.zero_left MeasureTheory.Measure.MutuallySingular.zero_left
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.mono_ac /-
 theorem mono_ac (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≪ μ₁) (hν : ν₂ ≪ ν₁) : μ₂ ⟂ₘ ν₂ :=
   let ⟨s, hs, h₁, h₂⟩ := h
   ⟨s, hs, hμ h₁, hν h₂⟩
 #align measure_theory.measure.mutually_singular.mono_ac MeasureTheory.Measure.MutuallySingular.mono_ac
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.mono /-
 theorem mono (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≤ μ₁) (hν : ν₂ ≤ ν₁) : μ₂ ⟂ₘ ν₂ :=
   h.mono_ac hμ.AbsolutelyContinuous hν.AbsolutelyContinuous
 #align measure_theory.measure.mutually_singular.mono MeasureTheory.Measure.MutuallySingular.mono
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.sum_left /-
 @[simp]
 theorem sum_left {ι : Type _} [Countable ι] {μ : ι → Measure α} : sum μ ⟂ₘ ν ↔ ∀ i, μ i ⟂ₘ ν :=
   by
@@ -95,37 +116,60 @@ theorem sum_left {ι : Type _} [Countable ι] {μ : ι → Measure α} : sum μ
     exact fun i => measure_mono_null (Inter_subset _ _) (hsμ i)
   · rwa [compl_Inter, measure_Union_null_iff]
 #align measure_theory.measure.mutually_singular.sum_left MeasureTheory.Measure.MutuallySingular.sum_left
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.sum_right /-
 @[simp]
 theorem sum_right {ι : Type _} [Countable ι] {ν : ι → Measure α} : μ ⟂ₘ sum ν ↔ ∀ i, μ ⟂ₘ ν i :=
   comm.trans <| sum_left.trans <| forall_congr' fun i => comm
 #align measure_theory.measure.mutually_singular.sum_right MeasureTheory.Measure.MutuallySingular.sum_right
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.add_left_iff /-
 @[simp]
 theorem add_left_iff : μ₁ + μ₂ ⟂ₘ ν ↔ μ₁ ⟂ₘ ν ∧ μ₂ ⟂ₘ ν := by
   rw [← sum_cond, sum_left, Bool.forall_bool, cond, cond, and_comm]
 #align measure_theory.measure.mutually_singular.add_left_iff MeasureTheory.Measure.MutuallySingular.add_left_iff
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.add_right_iff /-
 @[simp]
 theorem add_right_iff : μ ⟂ₘ ν₁ + ν₂ ↔ μ ⟂ₘ ν₁ ∧ μ ⟂ₘ ν₂ :=
   comm.trans <| add_left_iff.trans <| and_congr comm comm
 #align measure_theory.measure.mutually_singular.add_right_iff MeasureTheory.Measure.MutuallySingular.add_right_iff
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.add_left /-
 theorem add_left (h₁ : ν₁ ⟂ₘ μ) (h₂ : ν₂ ⟂ₘ μ) : ν₁ + ν₂ ⟂ₘ μ :=
   add_left_iff.2 ⟨h₁, h₂⟩
 #align measure_theory.measure.mutually_singular.add_left MeasureTheory.Measure.MutuallySingular.add_left
+-/
 
+#print MeasureTheory.Measure.MutuallySingular.add_right /-
 theorem add_right (h₁ : μ ⟂ₘ ν₁) (h₂ : μ ⟂ₘ ν₂) : μ ⟂ₘ ν₁ + ν₂ :=
   add_right_iff.2 ⟨h₁, h₂⟩
 #align measure_theory.measure.mutually_singular.add_right MeasureTheory.Measure.MutuallySingular.add_right
+-/
 
+/- warning: measure_theory.measure.mutually_singular.smul -> MeasureTheory.Measure.MutuallySingular.smul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} (r : ENNReal), (MeasureTheory.Measure.MutuallySingular.{u1} α m0 ν μ) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 (SMul.smul.{0, u1} ENNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instSMul.{u1, 0} α ENNReal (SMulZeroClass.toHasSmul.{0, 0} ENNReal ENNReal (AddZeroClass.toHasZero.{0} ENNReal (AddMonoid.toAddZeroClass.{0} ENNReal (AddCommMonoid.toAddMonoid.{0} ENNReal (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) (SMulWithZero.toSmulZeroClass.{0, 0} ENNReal ENNReal (MulZeroClass.toHasZero.{0} ENNReal (MulZeroOneClass.toMulZeroClass.{0} ENNReal (MonoidWithZero.toMulZeroOneClass.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))) (AddZeroClass.toHasZero.{0} ENNReal (AddMonoid.toAddZeroClass.{0} ENNReal (AddCommMonoid.toAddMonoid.{0} ENNReal (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) (MulActionWithZero.toSMulWithZero.{0, 0} ENNReal ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (AddZeroClass.toHasZero.{0} ENNReal (AddMonoid.toAddZeroClass.{0} ENNReal (AddCommMonoid.toAddMonoid.{0} ENNReal (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))))) (Module.toMulActionWithZero.{0, 0} ENNReal ENNReal (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)) (NonUnitalNonAssocSemiring.toAddCommMonoid.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))) (Algebra.toModule.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))))))) (IsScalarTower.right.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) m0) r ν) μ)
+but is expected to have type
+  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} (r : ENNReal), (MeasureTheory.Measure.MutuallySingular.{u1} α m0 ν μ) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 (HSMul.hSMul.{0, u1, u1} ENNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.{u1} α m0) (instHSMul.{0, u1} ENNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instSMul.{u1, 0} α ENNReal (Algebra.toSMul.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (IsScalarTower.right.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal) (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) m0)) r ν) μ)
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.mutually_singular.smul MeasureTheory.Measure.MutuallySingular.smulₓ'. -/
 theorem smul (r : ℝ≥0∞) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
   h.mono_ac (AbsolutelyContinuous.rfl.smul r) AbsolutelyContinuous.rfl
 #align measure_theory.measure.mutually_singular.smul MeasureTheory.Measure.MutuallySingular.smul
 
-theorem smul_nNReal (r : ℝ≥0) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
+/- warning: measure_theory.measure.mutually_singular.smul_nnreal -> MeasureTheory.Measure.MutuallySingular.smul_nnreal is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} (r : NNReal), (MeasureTheory.Measure.MutuallySingular.{u1} α m0 ν μ) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 (SMul.smul.{0, u1} NNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instSMul.{u1, 0} α NNReal (MulAction.toHasSmul.{0, 0} NNReal ENNReal (MonoidWithZero.toMonoid.{0} NNReal (Semiring.toMonoidWithZero.{0} NNReal NNReal.semiring)) (ENNReal.mulAction.{0} ENNReal (Monoid.toMulAction.{0} ENNReal (MonoidWithZero.toMonoid.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (ENNReal.isScalarTower.{0, 0} ENNReal ENNReal (Monoid.toMulAction.{0} ENNReal (MonoidWithZero.toMonoid.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))) (Monoid.toMulAction.{0} ENNReal (MonoidWithZero.toMonoid.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))) (Mul.toSMul.{0} ENNReal (Distrib.toHasMul.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (IsScalarTower.right.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))) m0) r ν) μ)
+but is expected to have type
+  forall {α : Type.{u1}} {m0 : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m0} {ν : MeasureTheory.Measure.{u1} α m0} (r : NNReal), (MeasureTheory.Measure.MutuallySingular.{u1} α m0 ν μ) -> (MeasureTheory.Measure.MutuallySingular.{u1} α m0 (HSMul.hSMul.{0, u1, u1} NNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.{u1} α m0) (instHSMul.{0, u1} NNReal (MeasureTheory.Measure.{u1} α m0) (MeasureTheory.Measure.instSMul.{u1, 0} α NNReal (Algebra.toSMul.{0, 0} NNReal ENNReal instNNRealCommSemiring (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (ENNReal.instAlgebraNNRealInstNNRealCommSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))) (ENNReal.instIsScalarTowerNNRealToSMulToMonoidToMonoidWithZeroInstNNRealSemiringInstMulActionNNRealToMonoidToMonoidWithZeroInstNNRealSemiringToSMulInstMulActionNNRealToMonoidToMonoidWithZeroInstNNRealSemiring.{0, 0} ENNReal ENNReal (MulActionWithZero.toMulAction.{0, 0} ENNReal ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))) instENNRealZero (MonoidWithZero.toMulActionWithZero.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))) (MulActionWithZero.toMulAction.{0, 0} ENNReal ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))) instENNRealZero (MonoidWithZero.toMulActionWithZero.{0} ENNReal (Semiring.toMonoidWithZero.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))) (Algebra.toSMul.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal) (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (IsScalarTower.right.{0, 0} ENNReal ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal) (CommSemiring.toSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)) (Algebra.id.{0} ENNReal (CanonicallyOrderedCommSemiring.toCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))) m0)) r ν) μ)
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.mutually_singular.smul_nnreal MeasureTheory.Measure.MutuallySingular.smul_nnrealₓ'. -/
+theorem smul_nnreal (r : ℝ≥0) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
   h.smul r
-#align measure_theory.measure.mutually_singular.smul_nnreal MeasureTheory.Measure.MutuallySingular.smul_nNReal
+#align measure_theory.measure.mutually_singular.smul_nnreal MeasureTheory.Measure.MutuallySingular.smul_nnreal
 
 end MutuallySingular
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/92c69b77c5a7dc0f7eeddb552508633305157caa

@@ -57,9 +57,9 @@ theorem mk {s t : Set α} (hs : μ s = 0) (ht : ν t = 0) (hst : univ ⊆ s ∪
 #align measure_theory.measure.mutually_singular.mk MeasureTheory.Measure.MutuallySingular.mk
 
 @[simp]
-theorem zeroRight : μ ⟂ₘ 0 :=
+theorem zero_right : μ ⟂ₘ 0 :=
   ⟨∅, MeasurableSet.empty, measure_empty, rfl⟩
-#align measure_theory.measure.mutually_singular.zero_right MeasureTheory.Measure.MutuallySingular.zeroRight
+#align measure_theory.measure.mutually_singular.zero_right MeasureTheory.Measure.MutuallySingular.zero_right
 
 @[symm]
 theorem symm (h : ν ⟂ₘ μ) : μ ⟂ₘ ν :=
@@ -72,17 +72,17 @@ theorem comm : μ ⟂ₘ ν ↔ ν ⟂ₘ μ :=
 #align measure_theory.measure.mutually_singular.comm MeasureTheory.Measure.MutuallySingular.comm
 
 @[simp]
-theorem zeroLeft : 0 ⟂ₘ μ :=
-  zeroRight.symm
-#align measure_theory.measure.mutually_singular.zero_left MeasureTheory.Measure.MutuallySingular.zeroLeft
+theorem zero_left : 0 ⟂ₘ μ :=
+  zero_right.symm
+#align measure_theory.measure.mutually_singular.zero_left MeasureTheory.Measure.MutuallySingular.zero_left
 
-theorem monoAc (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≪ μ₁) (hν : ν₂ ≪ ν₁) : μ₂ ⟂ₘ ν₂ :=
+theorem mono_ac (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≪ μ₁) (hν : ν₂ ≪ ν₁) : μ₂ ⟂ₘ ν₂ :=
   let ⟨s, hs, h₁, h₂⟩ := h
   ⟨s, hs, hμ h₁, hν h₂⟩
-#align measure_theory.measure.mutually_singular.mono_ac MeasureTheory.Measure.MutuallySingular.monoAc
+#align measure_theory.measure.mutually_singular.mono_ac MeasureTheory.Measure.MutuallySingular.mono_ac
 
 theorem mono (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≤ μ₁) (hν : ν₂ ≤ ν₁) : μ₂ ⟂ₘ ν₂ :=
-  h.monoAc hμ.AbsolutelyContinuous hν.AbsolutelyContinuous
+  h.mono_ac hμ.AbsolutelyContinuous hν.AbsolutelyContinuous
 #align measure_theory.measure.mutually_singular.mono MeasureTheory.Measure.MutuallySingular.mono
 
 @[simp]
@@ -111,21 +111,21 @@ theorem add_right_iff : μ ⟂ₘ ν₁ + ν₂ ↔ μ ⟂ₘ ν₁ ∧ μ ⟂
   comm.trans <| add_left_iff.trans <| and_congr comm comm
 #align measure_theory.measure.mutually_singular.add_right_iff MeasureTheory.Measure.MutuallySingular.add_right_iff
 
-theorem addLeft (h₁ : ν₁ ⟂ₘ μ) (h₂ : ν₂ ⟂ₘ μ) : ν₁ + ν₂ ⟂ₘ μ :=
+theorem add_left (h₁ : ν₁ ⟂ₘ μ) (h₂ : ν₂ ⟂ₘ μ) : ν₁ + ν₂ ⟂ₘ μ :=
   add_left_iff.2 ⟨h₁, h₂⟩
-#align measure_theory.measure.mutually_singular.add_left MeasureTheory.Measure.MutuallySingular.addLeft
+#align measure_theory.measure.mutually_singular.add_left MeasureTheory.Measure.MutuallySingular.add_left
 
-theorem addRight (h₁ : μ ⟂ₘ ν₁) (h₂ : μ ⟂ₘ ν₂) : μ ⟂ₘ ν₁ + ν₂ :=
+theorem add_right (h₁ : μ ⟂ₘ ν₁) (h₂ : μ ⟂ₘ ν₂) : μ ⟂ₘ ν₁ + ν₂ :=
   add_right_iff.2 ⟨h₁, h₂⟩
-#align measure_theory.measure.mutually_singular.add_right MeasureTheory.Measure.MutuallySingular.addRight
+#align measure_theory.measure.mutually_singular.add_right MeasureTheory.Measure.MutuallySingular.add_right
 
 theorem smul (r : ℝ≥0∞) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
-  h.monoAc (AbsolutelyContinuous.rfl.smul r) AbsolutelyContinuous.rfl
+  h.mono_ac (AbsolutelyContinuous.rfl.smul r) AbsolutelyContinuous.rfl
 #align measure_theory.measure.mutually_singular.smul MeasureTheory.Measure.MutuallySingular.smul
 
-theorem smulNnreal (r : ℝ≥0) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
+theorem smul_nNReal (r : ℝ≥0) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
   h.smul r
-#align measure_theory.measure.mutually_singular.smul_nnreal MeasureTheory.Measure.MutuallySingular.smulNnreal
+#align measure_theory.measure.mutually_singular.smul_nnreal MeasureTheory.Measure.MutuallySingular.smul_nNReal
 
 end MutuallySingular
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/eb0cb4511aaef0da2462207b67358a0e1fe1e2ee

@@ -29,7 +29,7 @@ measure, mutually singular
 
 open Set
 
-open MeasureTheory NNReal Ennreal
+open MeasureTheory NNReal ENNReal
 
 namespace MeasureTheory
 
@@ -91,7 +91,7 @@ theorem sum_left {ι : Type _} [Countable ι] {μ : ι → Measure α} : sum μ
   refine' ⟨fun h i => h.mono (le_sum _ _) le_rfl, fun H => _⟩
   choose s hsm hsμ hsν using H
   refine' ⟨⋂ i, s i, MeasurableSet.interᵢ hsm, _, _⟩
-  · rw [sum_apply _ (MeasurableSet.interᵢ hsm), Ennreal.tsum_eq_zero]
+  · rw [sum_apply _ (MeasurableSet.interᵢ hsm), ENNReal.tsum_eq_zero]
     exact fun i => measure_mono_null (Inter_subset _ _) (hsμ i)
   · rwa [compl_Inter, measure_Union_null_iff]
 #align measure_theory.measure.mutually_singular.sum_left MeasureTheory.Measure.MutuallySingular.sum_left

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

Also golf and move rnDeriv_restrict.

@@ -151,6 +151,11 @@ theorem smul_nnreal (r : ℝ≥0) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
   h.smul r
 #align measure_theory.measure.mutually_singular.smul_nnreal MeasureTheory.Measure.MutuallySingular.smul_nnreal
 
+lemma restrict (h : μ ⟂ₘ ν) (s : Set α) : μ.restrict s ⟂ₘ ν := by
+  refine ⟨h.nullSet, h.measurableSet_nullSet, ?_, h.measure_compl_nullSet⟩
+  rw [Measure.restrict_apply h.measurableSet_nullSet]
+  exact measure_mono_null (Set.inter_subset_left _ _) h.measure_nullSet
+
 end MutuallySingular
 
 lemma eq_zero_of_absolutelyContinuous_of_mutuallySingular {μ ν : Measure α}

Quoting [@digama0](https://github.com/digama0):

These were actually never meant to go in the file, they are basically debugging information and only useful on significantly broken mathport files. You can safely remove all of them.

@@ -40,7 +40,6 @@ def MutuallySingular {_ : MeasurableSpace α} (μ ν : Measure α) : Prop :=
   ∃ s : Set α, MeasurableSet s ∧ μ s = 0 ∧ ν sᶜ = 0
 #align measure_theory.measure.mutually_singular MeasureTheory.Measure.MutuallySingular
 
--- mathport name: measure.mutually_singular
 @[inherit_doc MeasureTheory.Measure.MutuallySingular]
 scoped[MeasureTheory] infixl:60 " ⟂ₘ " => MeasureTheory.Measure.MutuallySingular
 

Let γ be a countably generated measurable space and κ η : kernel α γ be finite kernels. We build a function rnDeriv κ η : α → γ → ℝ≥0∞ jointly measurable on α × γ and a kernel singularPart κ η : kernel α γ such that κ = withDensity η (rnDeriv κ η) + singularPart κ η and for all a : α, singularPart κ η a ⟂ₘ η a .

@@ -154,6 +154,12 @@ theorem smul_nnreal (r : ℝ≥0) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ :=
 
 end MutuallySingular
 
+lemma eq_zero_of_absolutelyContinuous_of_mutuallySingular {μ ν : Measure α}
+    (h_ac : μ ≪ ν) (h_ms : μ ⟂ₘ ν) :
+    μ = 0 := by
+  rw [← Measure.MutuallySingular.self_iff]
+  exact h_ms.mono_ac Measure.AbsolutelyContinuous.rfl h_ac
+
 end Measure
 
 end MeasureTheory

The original file MeasureSpace.lean is a mess of 4580 lines, with a lot of changes of namespaces, active variables, and so on. We split it into three files:

• MeasureSpace, with 2095 lines left (some stuff could still be moved to other files, but it already makes much more sense)
• Restrict, with everything on restriction of measures (1100 lines)
• Typeclasses, defining finite measures, sigma-finite measures, and so on (1443 lines)

The new files are still large, but less so. This is 99% moving around and ensuring that variables and namespaces remain the same (#align statements have been very useful for this), and 1% adding classical in proofs and [Decidable ...] assumptions in statements, as I haven't opened Classical in the new files.

@@ -3,7 +3,7 @@ Copyright (c) 2021 Kexing Ying. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kexing Ying, Yury Kudryashov
 -/
-import Mathlib.MeasureTheory.Measure.MeasureSpace
+import Mathlib.MeasureTheory.Measure.Restrict
 
 #align_import measure_theory.measure.mutually_singular from "leanprover-community/mathlib"@"70a4f2197832bceab57d7f41379b2592d1110570"
 

In order to remove that hypothesis, we also:

• add some basic lemmas about absolute continuity and mutually singular measures.
• add HaveLebesgueDecomposition instances
• rewrite the proof of withDensity_rnDeriv_eq to use the new API instead of unfolding the definitions
• generalize rnDeriv_restrict and rnDeriv_withDensity to possibly different measures

@@ -53,6 +53,27 @@ theorem mk {s t : Set α} (hs : μ s = 0) (ht : ν t = 0) (hst : univ ⊆ s ∪
   exact subset_toMeasurable _ _ hxs
 #align measure_theory.measure.mutually_singular.mk MeasureTheory.Measure.MutuallySingular.mk
 
+/-- A set such that `μ h.nullSet = 0` and `ν h.nullSetᶜ = 0`. -/
+def nullSet (h : μ ⟂ₘ ν) : Set α := h.choose
+
+lemma measurableSet_nullSet (h : μ ⟂ₘ ν) : MeasurableSet h.nullSet := h.choose_spec.1
+
+@[simp]
+lemma measure_nullSet (h : μ ⟂ₘ ν) : μ h.nullSet = 0 := h.choose_spec.2.1
+
+@[simp]
+lemma measure_compl_nullSet (h : μ ⟂ₘ ν) : ν h.nullSetᶜ = 0 := h.choose_spec.2.2
+
+-- TODO: this is proved by simp, but is not simplified in other contexts without the @[simp]
+-- attribute. Also, the linter does not complain about that attribute.
+@[simp]
+lemma restrict_nullSet (h : μ ⟂ₘ ν) : μ.restrict h.nullSet = 0 := by simp
+
+-- TODO: this is proved by simp, but is not simplified in other contexts without the @[simp]
+-- attribute. Also, the linter does not complain about that attribute.
+@[simp]
+lemma restrict_compl_nullSet (h : μ ⟂ₘ ν) : ν.restrict h.nullSetᶜ = 0 := by simp
+
 @[simp]
 theorem zero_right : μ ⟂ₘ 0 :=
   ⟨∅, MeasurableSet.empty, measure_empty, rfl⟩

Various results about rnDeriv, notably rnDeriv_add, rnDeriv_smul_left and rnDeriv_smul_right. These results describe the Radon-Nikodym derivatives of sums and scaling of measures.

These lemmas were already there for signed measures, but not for Measure. The proofs for signed measures use that addition is cancelative (μ + ν₁ = μ + ν₂ ↔ ν₁ = ν₂). This is not true in general for measures, but is true when μ is mutually singular with the two other measures or when μ is sigma-finite, which is enough for these proofs.

Co-authored-by: RemyDegenne <remydegenne@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -82,6 +82,14 @@ theorem mono (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≤ μ₁) (hν : ν₂ ≤ 
   h.mono_ac hμ.absolutelyContinuous hν.absolutelyContinuous
 #align measure_theory.measure.mutually_singular.mono MeasureTheory.Measure.MutuallySingular.mono
 
+@[simp]
+lemma self_iff (μ : Measure α) : μ ⟂ₘ μ ↔ μ = 0 := by
+  refine ⟨?_, fun h ↦ by (rw [h]; exact zero_left)⟩
+  rintro ⟨s, hs, hμs, hμs_compl⟩
+  suffices μ Set.univ = 0 by rwa [measure_univ_eq_zero] at this
+  rw [← Set.union_compl_self s, measure_union disjoint_compl_right hs.compl, hμs, hμs_compl,
+    add_zero]
+
 @[simp]
 theorem sum_left {ι : Type*} [Countable ι] {μ : ι → Measure α} : sum μ ⟂ₘ ν ↔ ∀ i, μ i ⟂ₘ ν := by
   refine' ⟨fun h i => h.mono (le_sum _ _) le_rfl, fun H => _⟩

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -32,7 +32,7 @@ namespace MeasureTheory
 
 namespace Measure
 
-variable {α : Type _} {m0 : MeasurableSpace α} {μ μ₁ μ₂ ν ν₁ ν₂ : Measure α}
+variable {α : Type*} {m0 : MeasurableSpace α} {μ μ₁ μ₂ ν ν₁ ν₂ : Measure α}
 
 /-- Two measures `μ`, `ν` are said to be mutually singular if there exists a measurable set `s`
 such that `μ s = 0` and `ν sᶜ = 0`. -/
@@ -83,7 +83,7 @@ theorem mono (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≤ μ₁) (hν : ν₂ ≤ 
 #align measure_theory.measure.mutually_singular.mono MeasureTheory.Measure.MutuallySingular.mono
 
 @[simp]
-theorem sum_left {ι : Type _} [Countable ι] {μ : ι → Measure α} : sum μ ⟂ₘ ν ↔ ∀ i, μ i ⟂ₘ ν := by
+theorem sum_left {ι : Type*} [Countable ι] {μ : ι → Measure α} : sum μ ⟂ₘ ν ↔ ∀ i, μ i ⟂ₘ ν := by
   refine' ⟨fun h i => h.mono (le_sum _ _) le_rfl, fun H => _⟩
   choose s hsm hsμ hsν using H
   refine' ⟨⋂ i, s i, MeasurableSet.iInter hsm, _, _⟩
@@ -93,7 +93,7 @@ theorem sum_left {ι : Type _} [Countable ι] {μ : ι → Measure α} : sum μ
 #align measure_theory.measure.mutually_singular.sum_left MeasureTheory.Measure.MutuallySingular.sum_left
 
 @[simp]
-theorem sum_right {ι : Type _} [Countable ι] {ν : ι → Measure α} : μ ⟂ₘ sum ν ↔ ∀ i, μ ⟂ₘ ν i :=
+theorem sum_right {ι : Type*} [Countable ι] {ν : ι → Measure α} : μ ⟂ₘ sum ν ↔ ∀ i, μ ⟂ₘ ν i :=
   comm.trans <| sum_left.trans <| forall_congr' fun _ => comm
 #align measure_theory.measure.mutually_singular.sum_right MeasureTheory.Measure.MutuallySingular.sum_right
 

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,14 +2,11 @@
 Copyright (c) 2021 Kexing Ying. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kexing Ying, Yury Kudryashov
-
-! This file was ported from Lean 3 source module measure_theory.measure.mutually_singular
-! leanprover-community/mathlib commit 70a4f2197832bceab57d7f41379b2592d1110570
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.MeasureTheory.Measure.MeasureSpace
 
+#align_import measure_theory.measure.mutually_singular from "leanprover-community/mathlib"@"70a4f2197832bceab57d7f41379b2592d1110570"
+
 /-! # Mutually singular measures
 
 Two measures `μ`, `ν` are said to be mutually singular (`MeasureTheory.Measure.MutuallySingular`,

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -40,7 +40,7 @@ variable {α : Type _} {m0 : MeasurableSpace α} {μ μ₁ μ₂ ν ν₁ ν₂
 /-- Two measures `μ`, `ν` are said to be mutually singular if there exists a measurable set `s`
 such that `μ s = 0` and `ν sᶜ = 0`. -/
 def MutuallySingular {_ : MeasurableSpace α} (μ ν : Measure α) : Prop :=
-  ∃ s : Set α, MeasurableSet s ∧ μ s = 0 ∧ ν (sᶜ) = 0
+  ∃ s : Set α, MeasurableSet s ∧ μ s = 0 ∧ ν sᶜ = 0
 #align measure_theory.measure.mutually_singular MeasureTheory.Measure.MutuallySingular
 
 -- mathport name: measure.mutually_singular

As discussed on Zulip

Renames

• supₛ → sSup
• infₛ → sInf
• supᵢ → iSup
• infᵢ → iInf
• bsupₛ → bsSup
• binfₛ → bsInf
• bsupᵢ → biSup
• binfᵢ → biInf
• csupₛ → csSup
• cinfₛ → csInf
• csupᵢ → ciSup
• cinfᵢ → ciInf
• unionₛ → sUnion
• interₛ → sInter
• unionᵢ → iUnion
• interᵢ → iInter
• bunionₛ → bsUnion
• binterₛ → bsInter
• bunionᵢ → biUnion
• binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -89,10 +89,10 @@ theorem mono (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≤ μ₁) (hν : ν₂ ≤ 
 theorem sum_left {ι : Type _} [Countable ι] {μ : ι → Measure α} : sum μ ⟂ₘ ν ↔ ∀ i, μ i ⟂ₘ ν := by
   refine' ⟨fun h i => h.mono (le_sum _ _) le_rfl, fun H => _⟩
   choose s hsm hsμ hsν using H
-  refine' ⟨⋂ i, s i, MeasurableSet.interᵢ hsm, _, _⟩
-  · rw [sum_apply _ (MeasurableSet.interᵢ hsm), ENNReal.tsum_eq_zero]
-    exact fun i => measure_mono_null (interᵢ_subset _ _) (hsμ i)
-  · rwa [compl_interᵢ, measure_unionᵢ_null_iff]
+  refine' ⟨⋂ i, s i, MeasurableSet.iInter hsm, _, _⟩
+  · rw [sum_apply _ (MeasurableSet.iInter hsm), ENNReal.tsum_eq_zero]
+    exact fun i => measure_mono_null (iInter_subset _ _) (hsμ i)
+  · rwa [compl_iInter, measure_iUnion_null_iff]
 #align measure_theory.measure.mutually_singular.sum_left MeasureTheory.Measure.MutuallySingular.sum_left
 
 @[simp]

Co-authored-by: Komyyy <pol_tta@outlook.jp> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>