File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

full_name: MeasureTheory.VectorMeasure.m_iUnion'
code: /-- A vector measure on a measurable space `α` is a σ-additive `M`-valued function (for some `M`
an add monoid) such that the empty set and non-measurable sets are mapped to zero. -/
structure VectorMeasure (α : Type*) [MeasurableSpace α] (M : Type*) [AddCommMonoid M]
    [TopologicalSpace M] where
  measureOf' : Set α → M
  empty' : measureOf' ∅ = 0
  not_measurable' ⦃i : Set α⦄ : ¬MeasurableSet i → measureOf' i = 0
  m_iUnion' ⦃f : ℕ → Set α⦄ : (∀ i, MeasurableSet (f i)) → Pairwise (Disjoint on f) →
    HasSum (fun i => measureOf' (f i)) (measureOf' (⋃ i, f i))
goal: (∀ (i : ℕ), MeasurableSet (f i)) → Pairwise (Disjoint on f) → HasSum (fun i => ↑self (f i)) (↑self (⋃ i, f i))

full_name: MeasureTheory.VectorMeasure.measureOf'
code: /-- A vector measure on a measurable space `α` is a σ-additive `M`-valued function (for some `M`
an add monoid) such that the empty set and non-measurable sets are mapped to zero. -/
structure VectorMeasure (α : Type*) [MeasurableSpace α] (M : Type*) [AddCommMonoid M]
    [TopologicalSpace M] where
  measureOf' : Set α → M
  empty' : measureOf' ∅ = 0
  not_measurable' ⦃i : Set α⦄ : ¬MeasurableSet i → measureOf' i = 0
  m_iUnion' ⦃f : ℕ → Set α⦄ : (∀ i, MeasurableSet (f i)) → Pairwise (Disjoint on f) →
    HasSum (fun i => measureOf' (f i)) (measureOf' (⋃ i, f i))
goal: Set α → M

full_name: MeasureTheory.VectorMeasure.not_measurable'
code: /-- A vector measure on a measurable space `α` is a σ-additive `M`-valued function (for some `M`
an add monoid) such that the empty set and non-measurable sets are mapped to zero. -/
structure VectorMeasure (α : Type*) [MeasurableSpace α] (M : Type*) [AddCommMonoid M]
    [TopologicalSpace M] where
  measureOf' : Set α → M
  empty' : measureOf' ∅ = 0
  not_measurable' ⦃i : Set α⦄ : ¬MeasurableSet i → measureOf' i = 0
  m_iUnion' ⦃f : ℕ → Set α⦄ : (∀ i, MeasurableSet (f i)) → Pairwise (Disjoint on f) →
    HasSum (fun i => measureOf' (f i)) (measureOf' (⋃ i, f i))
goal: ¬MeasurableSet i → ↑self i = 0

full_name: MeasureTheory.VectorMeasure
code: /-- A vector measure on a measurable space `α` is a σ-additive `M`-valued function (for some `M`
an add monoid) such that the empty set and non-measurable sets are mapped to zero. -/
structure VectorMeasure (α : Type*) [MeasurableSpace α] (M : Type*) [AddCommMonoid M]
    [TopologicalSpace M] where
  measureOf' : Set α → M
  empty' : measureOf' ∅ = 0
  not_measurable' ⦃i : Set α⦄ : ¬MeasurableSet i → measureOf' i = 0
  m_iUnion' ⦃f : ℕ → Set α⦄ : (∀ i, MeasurableSet (f i)) → Pairwise (Disjoint on f) →
    HasSum (fun i => measureOf' (f i)) (measureOf' (⋃ i, f i))
goal: Type (max u_3 u_4)

full_name: MeasureTheory.VectorMeasure.empty'
code: /-- A vector measure on a measurable space `α` is a σ-additive `M`-valued function (for some `M`
an add monoid) such that the empty set and non-measurable sets are mapped to zero. -/
structure VectorMeasure (α : Type*) [MeasurableSpace α] (M : Type*) [AddCommMonoid M]
    [TopologicalSpace M] where
  measureOf' : Set α → M
  empty' : measureOf' ∅ = 0
  not_measurable' ⦃i : Set α⦄ : ¬MeasurableSet i → measureOf' i = 0
  m_iUnion' ⦃f : ℕ → Set α⦄ : (∀ i, MeasurableSet (f i)) → Pairwise (Disjoint on f) →
    HasSum (fun i => measureOf' (f i)) (measureOf' (⋃ i, f i))
goal: ↑self ∅ = 0

full_name: MeasureTheory.SignedMeasure
code: /-- A `SignedMeasure` is an `ℝ`-vector measure. -/
abbrev SignedMeasure (α : Type*) [MeasurableSpace α] 
goal: Type u_3

full_name: MeasureTheory.ComplexMeasure
code: /-- A `ComplexMeasure` is a `ℂ`-vector measure. -/
abbrev ComplexMeasure (α : Type*) [MeasurableSpace α] 
goal: Type u_3

full_name: MeasureTheory.VectorMeasure.instCoeFun
code: instance instCoeFun : CoeFun (VectorMeasure α M) fun _ => Set α → M 
goal: CoeFun (MeasureTheory.VectorMeasure α M) fun x => Set α → M

full_name: MeasureTheory.VectorMeasure.empty
code: @[simp]
theorem empty (v : VectorMeasure α M) : v ∅ = 0 
goal: ↑v ∅ = 0

full_name: MeasureTheory.VectorMeasure.not_measurable
code: theorem not_measurable (v : VectorMeasure α M) {i : Set α} (hi : ¬MeasurableSet i) : v i = 0 
goal: ↑v i = 0

full_name: MeasureTheory.VectorMeasure.m_iUnion
code: theorem m_iUnion (v : VectorMeasure α M) {f : ℕ → Set α} (hf₁ : ∀ i, MeasurableSet (f i))
    (hf₂ : Pairwise (Disjoint on f)) : HasSum (fun i => v (f i)) (v (⋃ i, f i)) 
goal: HasSum (fun i => ↑v (f i)) (↑v (⋃ i, f i))

full_name: MeasureTheory.VectorMeasure.of_disjoint_iUnion_nat
code: theorem of_disjoint_iUnion_nat [T2Space M] (v : VectorMeasure α M) {f : ℕ → Set α}
    (hf₁ : ∀ i, MeasurableSet (f i)) (hf₂ : Pairwise (Disjoint on f)) :
    v (⋃ i, f i) = ∑' i, v (f i) 
goal: ↑v (⋃ i, f i) = ∑' (i : ℕ), ↑v (f i)

full_name: MeasureTheory.VectorMeasure.coe_injective
code: theorem coe_injective : @Function.Injective (VectorMeasure α M) (Set α → M) (⇑) 
goal: Function.Injective MeasureTheory.VectorMeasure.measureOf'

full_name: MeasureTheory.VectorMeasure.ext_iff'
code: theorem ext_iff' (v w : VectorMeasure α M) : v = w ↔ ∀ i : Set α, v i = w i 
goal: v = w ↔ ∀ (i : Set α), ↑v i = ↑w i

full_name: MeasureTheory.VectorMeasure.ext_iff
code: theorem ext_iff (v w : VectorMeasure α M) : v = w ↔ ∀ i : Set α, MeasurableSet i → v i = w i 
goal: v = w ↔ ∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i

full_name: MeasureTheory.VectorMeasure.ext
code: @[ext]
theorem ext {s t : VectorMeasure α M} (h : ∀ i : Set α, MeasurableSet i → s i = t i) : s = t 
goal: s = t

full_name: MeasureTheory.VectorMeasure.hasSum_of_disjoint_iUnion
code: theorem hasSum_of_disjoint_iUnion [Countable β] {f : β → Set α} (hf₁ : ∀ i, MeasurableSet (f i))
    (hf₂ : Pairwise (Disjoint on f)) : HasSum (fun i => v (f i)) (v (⋃ i, f i)) 
goal: HasSum (fun i => ↑v (f i)) (↑v (⋃ i, f i))

full_name: MeasureTheory.VectorMeasure.of_disjoint_iUnion
code: theorem of_disjoint_iUnion [Countable β] {f : β → Set α} (hf₁ : ∀ i, MeasurableSet (f i))
    (hf₂ : Pairwise (Disjoint on f)) : v (⋃ i, f i) = ∑' i, v (f i) 
goal: ↑v (⋃ i, f i) = ∑' (i : β), ↑v (f i)

full_name: MeasureTheory.VectorMeasure.of_union
code: theorem of_union {A B : Set α} (h : Disjoint A B) (hA : MeasurableSet A) (hB : MeasurableSet B) :
    v (A ∪ B) = v A + v B 
goal: ↑v (A ∪ B) = ↑v A + ↑v B

full_name: MeasureTheory.VectorMeasure.of_add_of_diff
code: theorem of_add_of_diff {A B : Set α} (hA : MeasurableSet A) (hB : MeasurableSet B) (h : A ⊆ B) :
    v A + v (B \ A) = v B 
goal: ↑v A + ↑v (B \ A) = ↑v B

full_name: MeasureTheory.VectorMeasure.of_diff
code: theorem of_diff {M : Type*} [AddCommGroup M] [TopologicalSpace M] [T2Space M]
    {v : VectorMeasure α M} {A B : Set α} (hA : MeasurableSet A) (hB : MeasurableSet B)
    (h : A ⊆ B) : v (B \ A) = v B - v A 
goal: ↑v (B \ A) = ↑v B - ↑v A

full_name: MeasureTheory.VectorMeasure.of_diff_of_diff_eq_zero
code: theorem of_diff_of_diff_eq_zero {A B : Set α} (hA : MeasurableSet A) (hB : MeasurableSet B)
    (h' : v (B \ A) = 0) : v (A \ B) + v B = v A 
goal: ↑v (A \ B) + ↑v B = ↑v A

full_name: MeasureTheory.VectorMeasure.of_iUnion_nonneg
code: theorem of_iUnion_nonneg {M : Type*} [TopologicalSpace M] [OrderedAddCommMonoid M]
    [OrderClosedTopology M] {v : VectorMeasure α M} (hf₁ : ∀ i, MeasurableSet (f i))
    (hf₂ : Pairwise (Disjoint on f)) (hf₃ : ∀ i, 0 ≤ v (f i)) : 0 ≤ v (⋃ i, f i) 
goal: 0 ≤ ↑v (⋃ i, f i)

full_name: MeasureTheory.VectorMeasure.of_iUnion_nonpos
code: theorem of_iUnion_nonpos {M : Type*} [TopologicalSpace M] [OrderedAddCommMonoid M]
    [OrderClosedTopology M] {v : VectorMeasure α M} (hf₁ : ∀ i, MeasurableSet (f i))
    (hf₂ : Pairwise (Disjoint on f)) (hf₃ : ∀ i, v (f i) ≤ 0) : v (⋃ i, f i) ≤ 0 
goal: ↑v (⋃ i, f i) ≤ 0

full_name: MeasureTheory.VectorMeasure.of_nonneg_disjoint_union_eq_zero
code: theorem of_nonneg_disjoint_union_eq_zero {s : SignedMeasure α} {A B : Set α} (h : Disjoint A B)
    (hA₁ : MeasurableSet A) (hB₁ : MeasurableSet B) (hA₂ : 0 ≤ s A) (hB₂ : 0 ≤ s B)
    (hAB : s (A ∪ B) = 0) : s A = 0 
goal: ↑s A = 0

full_name: MeasureTheory.VectorMeasure.of_nonpos_disjoint_union_eq_zero
code: theorem of_nonpos_disjoint_union_eq_zero {s : SignedMeasure α} {A B : Set α} (h : Disjoint A B)
    (hA₁ : MeasurableSet A) (hB₁ : MeasurableSet B) (hA₂ : s A ≤ 0) (hB₂ : s B ≤ 0)
    (hAB : s (A ∪ B) = 0) : s A = 0 
goal: ↑s A = 0

full_name: MeasureTheory.VectorMeasure.smul
code: /-- Given a real number `r` and a signed measure `s`, `smul r s` is the signed
measure corresponding to the function `r • s`. -/
def smul (r : R) (v : VectorMeasure α M) : VectorMeasure α M 
goal: MeasureTheory.VectorMeasure α M

full_name: MeasureTheory.VectorMeasure.instSMul
code: instance instSMul : SMul R (VectorMeasure α M) 
goal: SMul R (MeasureTheory.VectorMeasure α M)

full_name: MeasureTheory.VectorMeasure.coe_smul
code: @[simp]
theorem coe_smul (r : R) (v : VectorMeasure α M) : ⇑(r • v) = r • ⇑v 
goal: ↑(r • v) = r • ↑v

full_name: MeasureTheory.VectorMeasure.smul_apply
code: theorem smul_apply (r : R) (v : VectorMeasure α M) (i : Set α) : (r • v) i = r • v i 
goal: ↑(r • v) i = r • ↑v i

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

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

full_name: MeasureTheory.VectorMeasure.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : VectorMeasure α M) = 0 
goal: ↑0 = 0

full_name: MeasureTheory.VectorMeasure.zero_apply
code: theorem zero_apply (i : Set α) : (0 : VectorMeasure α M) i = 0 
goal: ↑0 i = 0

full_name: MeasureTheory.VectorMeasure.add
code: /-- The sum of two vector measure is a vector measure. -/
def add (v w : VectorMeasure α M) : VectorMeasure α M 
goal: MeasureTheory.VectorMeasure α M

full_name: MeasureTheory.VectorMeasure.instAdd
code: instance instAdd : Add (VectorMeasure α M) 
goal: Add (MeasureTheory.VectorMeasure α M)

full_name: MeasureTheory.VectorMeasure.coe_add
code: @[simp]
theorem coe_add (v w : VectorMeasure α M) : ⇑(v + w) = v + w 
goal: ↑(v + w) = ↑v + ↑w

full_name: MeasureTheory.VectorMeasure.add_apply
code: theorem add_apply (v w : VectorMeasure α M) (i : Set α) : (v + w) i = v i + w i 
goal: ↑(v + w) i = ↑v i + ↑w i

full_name: MeasureTheory.VectorMeasure.instAddCommMonoid
code: instance instAddCommMonoid : AddCommMonoid (VectorMeasure α M) 
goal: AddCommMonoid (MeasureTheory.VectorMeasure α M)

full_name: MeasureTheory.VectorMeasure.coeFnAddMonoidHom
code: /-- `(⇑)` is an `AddMonoidHom`. -/
@[simps]
def coeFnAddMonoidHom : VectorMeasure α M →+ Set α → M 
goal: MeasureTheory.VectorMeasure α M →+ Set α → M

full_name: MeasureTheory.VectorMeasure.coeFnAddMonoidHom_apply
code: /-- `(⇑)` is an `AddMonoidHom`. -/
@[simps]
def coeFnAddMonoidHom : VectorMeasure α M →+ Set α → M 
goal: ∀ (a : Set α), MeasureTheory.VectorMeasure.coeFnAddMonoidHom self a = ↑self a

full_name: MeasureTheory.VectorMeasure.neg
code: /-- The negative of a vector measure is a vector measure. -/
def neg (v : VectorMeasure α M) : VectorMeasure α M 
goal: MeasureTheory.VectorMeasure α M

full_name: MeasureTheory.VectorMeasure.instNeg
code: instance instNeg : Neg (VectorMeasure α M) 
goal: Neg (MeasureTheory.VectorMeasure α M)

full_name: MeasureTheory.VectorMeasure.coe_neg
code: @[simp]
theorem coe_neg (v : VectorMeasure α M) : ⇑(-v) = -v 
goal: ↑(-v) = -↑v

full_name: MeasureTheory.VectorMeasure.neg_apply
code: theorem neg_apply (v : VectorMeasure α M) (i : Set α) : (-v) i = -v i 
goal: ↑(-v) i = -↑v i

full_name: MeasureTheory.VectorMeasure.sub
code: /-- The difference of two vector measure is a vector measure. -/
def sub (v w : VectorMeasure α M) : VectorMeasure α M 
goal: MeasureTheory.VectorMeasure α M

full_name: MeasureTheory.VectorMeasure.instSub
code: instance instSub : Sub (VectorMeasure α M) 
goal: Sub (MeasureTheory.VectorMeasure α M)

full_name: MeasureTheory.VectorMeasure.coe_sub
code: @[simp]
theorem coe_sub (v w : VectorMeasure α M) : ⇑(v - w) = v - w 
goal: ↑(v - w) = ↑v - ↑w

full_name: MeasureTheory.VectorMeasure.sub_apply
code: theorem sub_apply (v w : VectorMeasure α M) (i : Set α) : (v - w) i = v i - w i 
goal: ↑(v - w) i = ↑v i - ↑w i

full_name: MeasureTheory.VectorMeasure.instAddCommGroup
code: instance instAddCommGroup : AddCommGroup (VectorMeasure α M) 
goal: AddCommGroup (MeasureTheory.VectorMeasure α M)

full_name: MeasureTheory.VectorMeasure.instDistribMulAction
code: instance instDistribMulAction [ContinuousAdd M] : DistribMulAction R (VectorMeasure α M) 
goal: DistribMulAction R (MeasureTheory.VectorMeasure α M)

full_name: MeasureTheory.VectorMeasure.instModule
code: instance instModule [ContinuousAdd M] : Module R (VectorMeasure α M) 
goal: Module R (MeasureTheory.VectorMeasure α M)

full_name: MeasureTheory.Measure.toSignedMeasure
code: /-- A finite measure coerced into a real function is a signed measure. -/
@[simps]
def toSignedMeasure (μ : Measure α) [hμ : IsFiniteMeasure μ] : SignedMeasure α 
goal: MeasureTheory.SignedMeasure α

full_name: MeasureTheory.Measure.toSignedMeasure_apply
code: /-- A finite measure coerced into a real function is a signed measure. -/
@[simps]
def toSignedMeasure (μ : Measure α) [hμ : IsFiniteMeasure μ] : SignedMeasure α 
goal: ↑μ.toSignedMeasure s = if MeasurableSet s then (μ s).toReal else 0

full_name: MeasureTheory.Measure.toSignedMeasure_apply_measurable
code: theorem toSignedMeasure_apply_measurable {μ : Measure α} [IsFiniteMeasure μ] {i : Set α}
    (hi : MeasurableSet i) : μ.toSignedMeasure i = (μ i).toReal 
goal: ↑μ.toSignedMeasure i = (μ i).toReal

full_name: MeasureTheory.Measure.toSignedMeasure_congr
code: theorem toSignedMeasure_congr {μ ν : Measure α} [IsFiniteMeasure μ] [IsFiniteMeasure ν]
    (h : μ = ν) : μ.toSignedMeasure = ν.toSignedMeasure 
goal: μ.toSignedMeasure = ν.toSignedMeasure

full_name: MeasureTheory.Measure.toSignedMeasure_eq_toSignedMeasure_iff
code: theorem toSignedMeasure_eq_toSignedMeasure_iff {μ ν : Measure α} [IsFiniteMeasure μ]
    [IsFiniteMeasure ν] : μ.toSignedMeasure = ν.toSignedMeasure ↔ μ = ν 
goal: μ.toSignedMeasure = ν.toSignedMeasure ↔ μ = ν

full_name: MeasureTheory.Measure.toSignedMeasure_zero
code: @[simp]
theorem toSignedMeasure_zero : (0 : Measure α).toSignedMeasure = 0 
goal: MeasureTheory.Measure.toSignedMeasure 0 = 0

full_name: MeasureTheory.Measure.toSignedMeasure_add
code: @[simp]
theorem toSignedMeasure_add (μ ν : Measure α) [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
    (μ + ν).toSignedMeasure = μ.toSignedMeasure + ν.toSignedMeasure 
goal: (μ + ν).toSignedMeasure = μ.toSignedMeasure + ν.toSignedMeasure

full_name: MeasureTheory.Measure.toSignedMeasure_smul
code: @[simp]
theorem toSignedMeasure_smul (μ : Measure α) [IsFiniteMeasure μ] (r : ℝ≥0) :
    (r • μ).toSignedMeasure = r • μ.toSignedMeasure 
goal: (r • μ).toSignedMeasure = r • μ.toSignedMeasure

full_name: MeasureTheory.Measure.toENNRealVectorMeasure_apply
code: /-- A measure is a vector measure over `ℝ≥0∞`. -/
@[simps]
def toENNRealVectorMeasure (μ : Measure α) : VectorMeasure α ℝ≥0∞ 
goal: ↑μ.toENNRealVectorMeasure i = if MeasurableSet i then μ i else 0

full_name: MeasureTheory.Measure.toENNRealVectorMeasure
code: /-- A measure is a vector measure over `ℝ≥0∞`. -/
@[simps]
def toENNRealVectorMeasure (μ : Measure α) : VectorMeasure α ℝ≥0∞ 
goal: MeasureTheory.VectorMeasure α ℝ≥0∞

full_name: MeasureTheory.Measure.toENNRealVectorMeasure_apply_measurable
code: theorem toENNRealVectorMeasure_apply_measurable {μ : Measure α} {i : Set α} (hi : MeasurableSet i) :
    μ.toENNRealVectorMeasure i = μ i 
goal: ↑μ.toENNRealVectorMeasure i = μ i

full_name: MeasureTheory.Measure.toENNRealVectorMeasure_zero
code: @[simp]
theorem toENNRealVectorMeasure_zero : (0 : Measure α).toENNRealVectorMeasure = 0 
goal: MeasureTheory.Measure.toENNRealVectorMeasure 0 = 0

full_name: MeasureTheory.Measure.toENNRealVectorMeasure_add
code: @[simp]
theorem toENNRealVectorMeasure_add (μ ν : Measure α) :
    (μ + ν).toENNRealVectorMeasure = μ.toENNRealVectorMeasure + ν.toENNRealVectorMeasure 
goal: (μ + ν).toENNRealVectorMeasure = μ.toENNRealVectorMeasure + ν.toENNRealVectorMeasure

full_name: MeasureTheory.Measure.toSignedMeasure_sub_apply
code: theorem toSignedMeasure_sub_apply {μ ν : Measure α} [IsFiniteMeasure μ] [IsFiniteMeasure ν]
    {i : Set α} (hi : MeasurableSet i) :
    (μ.toSignedMeasure - ν.toSignedMeasure) i = (μ i).toReal - (ν i).toReal 
goal: ↑(μ.toSignedMeasure - ν.toSignedMeasure) i = (μ i).toReal - (ν i).toReal

full_name: MeasureTheory.VectorMeasure.ennrealToMeasure
code: /-- A vector measure over `ℝ≥0∞` is a measure. -/
def ennrealToMeasure {_ : MeasurableSpace α} (v : VectorMeasure α ℝ≥0∞) : Measure α 
goal: {x : MeasurableSpace α} → MeasureTheory.VectorMeasure α ℝ≥0∞ → MeasureTheory.Measure α

full_name: MeasureTheory.VectorMeasure.ennrealToMeasure_apply
code: theorem ennrealToMeasure_apply {m : MeasurableSpace α} {v : VectorMeasure α ℝ≥0∞} {s : Set α}
    (hs : MeasurableSet s) : ennrealToMeasure v s = v s 
goal: v.ennrealToMeasure s = ↑v s

full_name: MeasureTheory.Measure.toENNRealVectorMeasure_ennrealToMeasure
code: @[simp]
theorem _root_.MeasureTheory.Measure.toENNRealVectorMeasure_ennrealToMeasure
    (μ : VectorMeasure α ℝ≥0∞) :
    toENNRealVectorMeasure (ennrealToMeasure μ) = μ 
goal: μ.ennrealToMeasure.toENNRealVectorMeasure = μ

full_name: MeasureTheory.VectorMeasure.ennrealToMeasure_toENNRealVectorMeasure
code: @[simp]
theorem ennrealToMeasure_toENNRealVectorMeasure (μ : Measure α) :
    ennrealToMeasure (toENNRealVectorMeasure μ) = μ 
goal: μ.toENNRealVectorMeasure.ennrealToMeasure = μ

full_name: MeasureTheory.VectorMeasure.equivMeasure_symm_apply
code: /-- The equiv between `VectorMeasure α ℝ≥0∞` and `Measure α` formed by
`MeasureTheory.VectorMeasure.ennrealToMeasure` and
`MeasureTheory.Measure.toENNRealVectorMeasure`. -/
@[simps]
def equivMeasure [MeasurableSpace α] : VectorMeasure α ℝ≥0∞ ≃ Measure α 
goal: MeasureTheory.VectorMeasure.equivMeasure.symm μ = μ.toENNRealVectorMeasure

full_name: MeasureTheory.VectorMeasure.equivMeasure_apply
code: /-- The equiv between `VectorMeasure α ℝ≥0∞` and `Measure α` formed by
`MeasureTheory.VectorMeasure.ennrealToMeasure` and
`MeasureTheory.Measure.toENNRealVectorMeasure`. -/
@[simps]
def equivMeasure [MeasurableSpace α] : VectorMeasure α ℝ≥0∞ ≃ Measure α 
goal: MeasureTheory.VectorMeasure.equivMeasure v = v.ennrealToMeasure

full_name: MeasureTheory.VectorMeasure.equivMeasure
code: /-- The equiv between `VectorMeasure α ℝ≥0∞` and `Measure α` formed by
`MeasureTheory.VectorMeasure.ennrealToMeasure` and
`MeasureTheory.Measure.toENNRealVectorMeasure`. -/
@[simps]
def equivMeasure [MeasurableSpace α] : VectorMeasure α ℝ≥0∞ ≃ Measure α 
goal: MeasureTheory.VectorMeasure α ℝ≥0∞ ≃ MeasureTheory.Measure α

full_name: MeasureTheory.VectorMeasure.map
code: /-- The pushforward of a vector measure along a function. -/
def map (v : VectorMeasure α M) (f : α → β) : VectorMeasure β M 
goal: MeasureTheory.VectorMeasure β M

full_name: MeasureTheory.VectorMeasure.map_not_measurable
code: theorem map_not_measurable {f : α → β} (hf : ¬Measurable f) : v.map f = 0 
goal: v.map f = 0

full_name: MeasureTheory.VectorMeasure.map_apply
code: theorem map_apply {f : α → β} (hf : Measurable f) {s : Set β} (hs : MeasurableSet s) :
    v.map f s = v (f ⁻¹' s) 
goal: ↑(v.map f) s = ↑v (f ⁻¹' s)

full_name: MeasureTheory.VectorMeasure.map_id
code: @[simp]
theorem map_id : v.map id = v 
goal: v.map id = v

full_name: MeasureTheory.VectorMeasure.map_zero
code: @[simp]
theorem map_zero (f : α → β) : (0 : VectorMeasure α M).map f = 0 
goal: MeasureTheory.VectorMeasure.map 0 f = 0

full_name: MeasureTheory.VectorMeasure.mapRange
code: /-- Given a vector measure `v` on `M` and a continuous `AddMonoidHom` `f : M → N`, `f ∘ v` is a
vector measure on `N`. -/
def mapRange (v : VectorMeasure α M) (f : M →+ N) (hf : Continuous f) : VectorMeasure α N 
goal: MeasureTheory.VectorMeasure α N

full_name: MeasureTheory.VectorMeasure.mapRange_apply
code: @[simp]
theorem mapRange_apply {f : M →+ N} (hf : Continuous f) {s : Set α} : v.mapRange f hf s = f (v s) 
goal: ↑(v.mapRange f hf) s = f (↑v s)

full_name: MeasureTheory.VectorMeasure.mapRange_id
code: @[simp]
theorem mapRange_id : v.mapRange (AddMonoidHom.id M) continuous_id = v 
goal: v.mapRange (AddMonoidHom.id M) ⋯ = v

full_name: MeasureTheory.VectorMeasure.mapRange_zero
code: @[simp]
theorem mapRange_zero {f : M →+ N} (hf : Continuous f) :
    mapRange (0 : VectorMeasure α M) f hf = 0 
goal: MeasureTheory.VectorMeasure.mapRange 0 f hf = 0

full_name: MeasureTheory.VectorMeasure.mapRange_add
code: @[simp]
theorem mapRange_add {v w : VectorMeasure α M} {f : M →+ N} (hf : Continuous f) :
    (v + w).mapRange f hf = v.mapRange f hf + w.mapRange f hf 
goal: (v + w).mapRange f hf = v.mapRange f hf + w.mapRange f hf

full_name: MeasureTheory.VectorMeasure.mapRangeHom
code: /-- Given a continuous `AddMonoidHom` `f : M → N`, `mapRangeHom` is the `AddMonoidHom` mapping the
vector measure `v` on `M` to the vector measure `f ∘ v` on `N`. -/
def mapRangeHom (f : M →+ N) (hf : Continuous f) : VectorMeasure α M →+ VectorMeasure α N 
goal: MeasureTheory.VectorMeasure α M →+ MeasureTheory.VectorMeasure α N

full_name: MeasureTheory.VectorMeasure.mapRangeₗ
code: /-- Given a continuous linear map `f : M → N`, `mapRangeₗ` is the linear map mapping the
vector measure `v` on `M` to the vector measure `f ∘ v` on `N`. -/
def mapRangeₗ (f : M →ₗ[R] N) (hf : Continuous f) : VectorMeasure α M →ₗ[R] VectorMeasure α N 
goal: MeasureTheory.VectorMeasure α M →ₗ[R] MeasureTheory.VectorMeasure α N

full_name: MeasureTheory.VectorMeasure.restrict
code: /-- The restriction of a vector measure on some set. -/
def restrict (v : VectorMeasure α M) (i : Set α) : VectorMeasure α M 
goal: MeasureTheory.VectorMeasure α M

full_name: MeasureTheory.VectorMeasure.restrict_not_measurable
code: theorem restrict_not_measurable {i : Set α} (hi : ¬MeasurableSet i) : v.restrict i = 0 
goal: v.restrict i = 0

full_name: MeasureTheory.VectorMeasure.restrict_apply
code: theorem restrict_apply {i : Set α} (hi : MeasurableSet i) {j : Set α} (hj : MeasurableSet j) :
    v.restrict i j = v (j ∩ i) 
goal: ↑(v.restrict i) j = ↑v (j ∩ i)

full_name: MeasureTheory.VectorMeasure.restrict_eq_self
code: theorem restrict_eq_self {i : Set α} (hi : MeasurableSet i) {j : Set α} (hj : MeasurableSet j)
    (hij : j ⊆ i) : v.restrict i j = v j 
goal: ↑(v.restrict i) j = ↑v j

full_name: MeasureTheory.VectorMeasure.restrict_empty
code: @[simp]
theorem restrict_empty : v.restrict ∅ = 0 
goal: v.restrict ∅ = 0

full_name: MeasureTheory.VectorMeasure.restrict_univ
code: @[simp]
theorem restrict_univ : v.restrict Set.univ = v 
goal: v.restrict Set.univ = v

full_name: MeasureTheory.VectorMeasure.restrict_zero
code: @[simp]
theorem restrict_zero {i : Set α} : (0 : VectorMeasure α M).restrict i = 0 
goal: MeasureTheory.VectorMeasure.restrict 0 i = 0

full_name: MeasureTheory.VectorMeasure.map_add
code: theorem map_add (v w : VectorMeasure α M) (f : α → β) : (v + w).map f = v.map f + w.map f 
goal: (v + w).map f = v.map f + w.map f

full_name: MeasureTheory.VectorMeasure.mapGm_apply
code: /-- `VectorMeasure.map` as an additive monoid homomorphism. -/
@[simps]
def mapGm (f : α → β) : VectorMeasure α M →+ VectorMeasure β M 
goal: (MeasureTheory.VectorMeasure.mapGm f) v = v.map f

full_name: MeasureTheory.VectorMeasure.mapGm
code: /-- `VectorMeasure.map` as an additive monoid homomorphism. -/
@[simps]
def mapGm (f : α → β) : VectorMeasure α M →+ VectorMeasure β M 
goal: MeasureTheory.VectorMeasure α M →+ MeasureTheory.VectorMeasure β M

full_name: MeasureTheory.VectorMeasure.restrict_add
code: theorem restrict_add (v w : VectorMeasure α M) (i : Set α) :
    (v + w).restrict i = v.restrict i + w.restrict i 
goal: (v + w).restrict i = v.restrict i + w.restrict i

full_name: MeasureTheory.VectorMeasure.restrictGm_apply
code: /-- `VectorMeasure.restrict` as an additive monoid homomorphism. -/
@[simps]
def restrictGm (i : Set α) : VectorMeasure α M →+ VectorMeasure α M 
goal: (MeasureTheory.VectorMeasure.restrictGm i) v = v.restrict i

full_name: MeasureTheory.VectorMeasure.restrictGm
code: /-- `VectorMeasure.restrict` as an additive monoid homomorphism. -/
@[simps]
def restrictGm (i : Set α) : VectorMeasure α M →+ VectorMeasure α M 
goal: MeasureTheory.VectorMeasure α M →+ MeasureTheory.VectorMeasure α M

full_name: MeasureTheory.VectorMeasure.map_smul
code: @[simp]
theorem map_smul {v : VectorMeasure α M} {f : α → β} (c : R) : (c • v).map f = c • v.map f 
goal: (c • v).map f = c • v.map f

full_name: MeasureTheory.VectorMeasure.restrict_smul
code: @[simp]
theorem restrict_smul {v : VectorMeasure α M} {i : Set α} (c : R) :
    (c • v).restrict i = c • v.restrict i 
goal: (c • v).restrict i = c • v.restrict i

full_name: MeasureTheory.VectorMeasure.mapₗ_apply
code: /-- `VectorMeasure.map` as a linear map. -/
@[simps]
def mapₗ (f : α → β) : VectorMeasure α M →ₗ[R] VectorMeasure β M 
goal: (MeasureTheory.VectorMeasure.mapₗ f) v = v.map f

full_name: MeasureTheory.VectorMeasure.mapₗ
code: /-- `VectorMeasure.map` as a linear map. -/
@[simps]
def mapₗ (f : α → β) : VectorMeasure α M →ₗ[R] VectorMeasure β M 
goal: MeasureTheory.VectorMeasure α M →ₗ[R] MeasureTheory.VectorMeasure β M

full_name: MeasureTheory.VectorMeasure.restrictₗ
code: /-- `VectorMeasure.restrict` as an additive monoid homomorphism. -/
@[simps]
def restrictₗ (i : Set α) : VectorMeasure α M →ₗ[R] VectorMeasure α M 
goal: MeasureTheory.VectorMeasure α M →ₗ[R] MeasureTheory.VectorMeasure α M

full_name: MeasureTheory.VectorMeasure.restrictₗ_apply
code: /-- `VectorMeasure.restrict` as an additive monoid homomorphism. -/
@[simps]
def restrictₗ (i : Set α) : VectorMeasure α M →ₗ[R] VectorMeasure α M 
goal: (MeasureTheory.VectorMeasure.restrictₗ i) v = v.restrict i

full_name: MeasureTheory.VectorMeasure.instPartialOrder
code: /-- Vector measures over a partially ordered monoid is partially ordered.

This definition is consistent with `Measure.instPartialOrder`. -/
instance instPartialOrder : PartialOrder (VectorMeasure α M) 
goal: PartialOrder (MeasureTheory.VectorMeasure α M)

full_name: MeasureTheory.VectorMeasure.le_iff
code: theorem le_iff : v ≤ w ↔ ∀ i, MeasurableSet i → v i ≤ w i 
goal: v ≤ w ↔ ∀ (i : Set α), MeasurableSet i → ↑v i ≤ ↑w i

full_name: MeasureTheory.VectorMeasure.le_iff'
code: theorem le_iff' : v ≤ w ↔ ∀ i, v i ≤ w i 
goal: v ≤ w ↔ ∀ (i : Set α), ↑v i ≤ ↑w i

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Measure_VectorMeasure___macroRules_MeasureTheory_term_≤[_]__1»
code: scoped[MeasureTheory]
  notation:50 v " ≤[" i:50 "] " w:50 =>
    MeasureTheory.VectorMeasure.restrict v i ≤ MeasureTheory.VectorMeasure.restrict w i
goal: Lean.Macro

full_name: MeasureTheory.VectorMeasure.restrict_le_restrict_iff
code: theorem restrict_le_restrict_iff {i : Set α} (hi : MeasurableSet i) :
    v ≤[i] w ↔ ∀ ⦃j⦄, MeasurableSet j → j ⊆ i → v j ≤ w j 
goal: v.restrict i ≤ w.restrict i ↔ ∀ ⦃j : Set α⦄, MeasurableSet j → j ⊆ i → ↑v j ≤ ↑w j

full_name: MeasureTheory.VectorMeasure.subset_le_of_restrict_le_restrict
code: theorem subset_le_of_restrict_le_restrict {i : Set α} (hi : MeasurableSet i) (hi₂ : v ≤[i] w)
    {j : Set α} (hj : j ⊆ i) : v j ≤ w j 
goal: ↑v j ≤ ↑w j

full_name: MeasureTheory.VectorMeasure.restrict_le_restrict_of_subset_le
code: theorem restrict_le_restrict_of_subset_le {i : Set α}
    (h : ∀ ⦃j⦄, MeasurableSet j → j ⊆ i → v j ≤ w j) : v ≤[i] w 
goal: v.restrict i ≤ w.restrict i

full_name: MeasureTheory.VectorMeasure.restrict_le_restrict_subset
code: theorem restrict_le_restrict_subset {i j : Set α} (hi₁ : MeasurableSet i) (hi₂ : v ≤[i] w)
    (hij : j ⊆ i) : v ≤[j] w 
goal: v.restrict j ≤ w.restrict j

full_name: MeasureTheory.VectorMeasure.le_restrict_empty
code: theorem le_restrict_empty : v ≤[∅] w 
goal: v.restrict ∅ ≤ w.restrict ∅

full_name: MeasureTheory.VectorMeasure.le_restrict_univ_iff_le
code: theorem le_restrict_univ_iff_le : v ≤[Set.univ] w ↔ v ≤ w 
goal: v.restrict Set.univ ≤ w.restrict Set.univ ↔ v ≤ w

full_name: MeasureTheory.VectorMeasure.neg_le_neg
code: nonrec theorem neg_le_neg {i : Set α} (hi : MeasurableSet i) (h : v ≤[i] w) : -w ≤[i] -v 
goal: (-w).restrict i ≤ (-v).restrict i

full_name: MeasureTheory.VectorMeasure.neg_le_neg_iff
code: @[simp]
theorem neg_le_neg_iff {i : Set α} (hi : MeasurableSet i) : -w ≤[i] -v ↔ v ≤[i] w 
goal: (-w).restrict i ≤ (-v).restrict i ↔ v.restrict i ≤ w.restrict i

full_name: MeasureTheory.VectorMeasure.restrict_le_restrict_iUnion
code: theorem restrict_le_restrict_iUnion {f : ℕ → Set α} (hf₁ : ∀ n, MeasurableSet (f n))
    (hf₂ : ∀ n, v ≤[f n] w) : v ≤[⋃ n, f n] w 
goal: v.restrict (⋃ n, f n) ≤ w.restrict (⋃ n, f n)

full_name: MeasureTheory.VectorMeasure.restrict_le_restrict_countable_iUnion
code: theorem restrict_le_restrict_countable_iUnion [Countable β] {f : β → Set α}
    (hf₁ : ∀ b, MeasurableSet (f b)) (hf₂ : ∀ b, v ≤[f b] w) : v ≤[⋃ b, f b] w 
goal: v.restrict (⋃ b, f b) ≤ w.restrict (⋃ b, f b)

full_name: MeasureTheory.VectorMeasure.restrict_le_restrict_union
code: theorem restrict_le_restrict_union (hi₁ : MeasurableSet i) (hi₂ : v ≤[i] w) (hj₁ : MeasurableSet j)
    (hj₂ : v ≤[j] w) : v ≤[i ∪ j] w 
goal: v.restrict (i ∪ j) ≤ w.restrict (i ∪ j)

full_name: MeasureTheory.VectorMeasure.nonneg_of_zero_le_restrict
code: theorem nonneg_of_zero_le_restrict (hi₂ : 0 ≤[i] v) : 0 ≤ v i 
goal: 0 ≤ ↑v i

full_name: MeasureTheory.VectorMeasure.nonpos_of_restrict_le_zero
code: theorem nonpos_of_restrict_le_zero (hi₂ : v ≤[i] 0) : v i ≤ 0 
goal: ↑v i ≤ 0

full_name: MeasureTheory.VectorMeasure.zero_le_restrict_not_measurable
code: theorem zero_le_restrict_not_measurable (hi : ¬MeasurableSet i) : 0 ≤[i] v 
goal: MeasureTheory.VectorMeasure.restrict 0 i ≤ v.restrict i

full_name: MeasureTheory.VectorMeasure.restrict_le_zero_of_not_measurable
code: theorem restrict_le_zero_of_not_measurable (hi : ¬MeasurableSet i) : v ≤[i] 0 
goal: v.restrict i ≤ MeasureTheory.VectorMeasure.restrict 0 i

full_name: MeasureTheory.VectorMeasure.measurable_of_not_zero_le_restrict
code: theorem measurable_of_not_zero_le_restrict (hi : ¬0 ≤[i] v) : MeasurableSet i 
goal: MeasurableSet i

full_name: MeasureTheory.VectorMeasure.measurable_of_not_restrict_le_zero
code: theorem measurable_of_not_restrict_le_zero (hi : ¬v ≤[i] 0) : MeasurableSet i 
goal: MeasurableSet i

full_name: MeasureTheory.VectorMeasure.zero_le_restrict_subset
code: theorem zero_le_restrict_subset (hi₁ : MeasurableSet i) (hij : j ⊆ i) (hi₂ : 0 ≤[i] v) : 0 ≤[j] v 
goal: MeasureTheory.VectorMeasure.restrict 0 j ≤ v.restrict j

full_name: MeasureTheory.VectorMeasure.restrict_le_zero_subset
code: theorem restrict_le_zero_subset (hi₁ : MeasurableSet i) (hij : j ⊆ i) (hi₂ : v ≤[i] 0) : v ≤[j] 0 
goal: v.restrict j ≤ MeasureTheory.VectorMeasure.restrict 0 j

full_name: MeasureTheory.VectorMeasure.exists_pos_measure_of_not_restrict_le_zero
code: theorem exists_pos_measure_of_not_restrict_le_zero (hi : ¬v ≤[i] 0) :
    ∃ j : Set α, MeasurableSet j ∧ j ⊆ i ∧ 0 < v j 
goal: ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j

full_name: MeasureTheory.VectorMeasure.covariant_add_le
code: instance covariant_add_le :
    CovariantClass (VectorMeasure α M) (VectorMeasure α M) (· + ·) (· ≤ ·) 
goal: CovariantClass (MeasureTheory.VectorMeasure α M) (MeasureTheory.VectorMeasure α M) (fun x x_1 => x + x_1) fun x x_1 =>
  x ≤ x_1

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous
code: /-- A vector measure `v` is absolutely continuous with respect to a measure `μ` if for all sets
`s`, `μ s = 0`, we have `v s = 0`. -/
def AbsolutelyContinuous (v : VectorMeasure α M) (w : VectorMeasure α N) 
goal: Prop

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Measure_VectorMeasure___macroRules_MeasureTheory_term_≪ᵥ__1»
code: @[inherit_doc VectorMeasure.AbsolutelyContinuous]
scoped[MeasureTheory] infixl:50 " ≪ᵥ " => MeasureTheory.VectorMeasure.AbsolutelyContinuous
goal: Lean.Macro

full_name: MeasureTheory._aux_Mathlib_MeasureTheory_Measure_VectorMeasure___unexpand_MeasureTheory_VectorMeasure_AbsolutelyContinuous_1
code: @[inherit_doc VectorMeasure.AbsolutelyContinuous]
scoped[MeasureTheory] infixl:50 " ≪ᵥ " => MeasureTheory.VectorMeasure.AbsolutelyContinuous
goal: Lean.PrettyPrinter.Unexpander

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.mk
code: theorem mk (h : ∀ ⦃s : Set α⦄, MeasurableSet s → w s = 0 → v s = 0) : v ≪ᵥ w 
goal: v ≪ᵥ w

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.eq
code: theorem eq {w : VectorMeasure α M} (h : v = w) : v ≪ᵥ w 
goal: v ≪ᵥ w

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.refl
code: @[refl]
theorem refl (v : VectorMeasure α M) : v ≪ᵥ v 
goal: v ≪ᵥ v

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.trans
code: @[trans]
theorem trans {u : VectorMeasure α L} {v : VectorMeasure α M} {w : VectorMeasure α N} (huv : u ≪ᵥ v)
    (hvw : v ≪ᵥ w) : u ≪ᵥ w 
goal: u ≪ᵥ w

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.zero
code: theorem zero (v : VectorMeasure α N) : (0 : VectorMeasure α M) ≪ᵥ v 
goal: 0 ≪ᵥ v

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.neg_left
code: theorem neg_left {M : Type*} [AddCommGroup M] [TopologicalSpace M] [TopologicalAddGroup M]
    {v : VectorMeasure α M} {w : VectorMeasure α N} (h : v ≪ᵥ w) : -v ≪ᵥ w 
goal: -v ≪ᵥ w

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.neg_right
code: theorem neg_right {N : Type*} [AddCommGroup N] [TopologicalSpace N] [TopologicalAddGroup N]
    {v : VectorMeasure α M} {w : VectorMeasure α N} (h : v ≪ᵥ w) : v ≪ᵥ -w 
goal: v ≪ᵥ -w

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.add
code: theorem add [ContinuousAdd M] {v₁ v₂ : VectorMeasure α M} {w : VectorMeasure α N} (hv₁ : v₁ ≪ᵥ w)
    (hv₂ : v₂ ≪ᵥ w) : v₁ + v₂ ≪ᵥ w 
goal: v₁ + v₂ ≪ᵥ w

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.sub
code: theorem sub {M : Type*} [AddCommGroup M] [TopologicalSpace M] [TopologicalAddGroup M]
    {v₁ v₂ : VectorMeasure α M} {w : VectorMeasure α N} (hv₁ : v₁ ≪ᵥ w) (hv₂ : v₂ ≪ᵥ w) :
    v₁ - v₂ ≪ᵥ w 
goal: v₁ - v₂ ≪ᵥ w

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.smul
code: theorem smul {R : Type*} [Semiring R] [DistribMulAction R M] [ContinuousConstSMul R M] {r : R}
    {v : VectorMeasure α M} {w : VectorMeasure α N} (h : v ≪ᵥ w) : r • v ≪ᵥ w 
goal: r • v ≪ᵥ w

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.map
code: theorem map [MeasureSpace β] (h : v ≪ᵥ w) (f : α → β) : v.map f ≪ᵥ w.map f 
goal: v.map f ≪ᵥ w.map f

full_name: MeasureTheory.VectorMeasure.AbsolutelyContinuous.ennrealToMeasure
code: theorem ennrealToMeasure {μ : VectorMeasure α ℝ≥0∞} :
    (∀ ⦃s : Set α⦄, μ.ennrealToMeasure s = 0 → v s = 0) ↔ v ≪ᵥ μ 
goal: (∀ ⦃s : Set α⦄, μ.ennrealToMeasure s = 0 → ↑v s = 0) ↔ v ≪ᵥ μ

full_name: MeasureTheory.VectorMeasure.MutuallySingular
code: /-- Two vector measures `v` and `w` are said to be mutually singular if there exists a measurable
set `s`, such that for all `t ⊆ s`, `v t = 0` and for all `t ⊆ sᶜ`, `w t = 0`.

We note that we do not require the measurability of `t` in the definition since this makes it easier
to use. This is equivalent to the definition which requires measurability. To prove
`MutuallySingular` with the measurability condition, use
`MeasureTheory.VectorMeasure.MutuallySingular.mk`. -/
def MutuallySingular (v : VectorMeasure α M) (w : VectorMeasure α N) : Prop 
goal: Prop

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Measure_VectorMeasure___macroRules_MeasureTheory_term_⟂ᵥ__1»
code: @[inherit_doc VectorMeasure.MutuallySingular]
scoped[MeasureTheory] infixl:60 " ⟂ᵥ " => MeasureTheory.VectorMeasure.MutuallySingular
goal: Lean.Macro

full_name: MeasureTheory._aux_Mathlib_MeasureTheory_Measure_VectorMeasure___unexpand_MeasureTheory_VectorMeasure_MutuallySingular_1
code: @[inherit_doc VectorMeasure.MutuallySingular]
scoped[MeasureTheory] infixl:60 " ⟂ᵥ " => MeasureTheory.VectorMeasure.MutuallySingular
goal: Lean.PrettyPrinter.Unexpander

full_name: MeasureTheory.VectorMeasure.MutuallySingular.mk
code: theorem mk (s : Set α) (hs : MeasurableSet s) (h₁ : ∀ t ⊆ s, MeasurableSet t → v t = 0)
    (h₂ : ∀ t ⊆ sᶜ, MeasurableSet t → w t = 0) : v ⟂ᵥ w 
goal: v ⟂ᵥ w

full_name: MeasureTheory.VectorMeasure.MutuallySingular.symm
code: theorem symm (h : v ⟂ᵥ w) : w ⟂ᵥ v 
goal: w ⟂ᵥ v

full_name: MeasureTheory.VectorMeasure.MutuallySingular.zero_right
code: theorem zero_right : v ⟂ᵥ (0 : VectorMeasure α N) 
goal: v ⟂ᵥ 0

full_name: MeasureTheory.VectorMeasure.MutuallySingular.zero_left
code: theorem zero_left : (0 : VectorMeasure α M) ⟂ᵥ w 
goal: 0 ⟂ᵥ w

full_name: MeasureTheory.VectorMeasure.MutuallySingular.add_left
code: theorem add_left [T2Space N] [ContinuousAdd M] (h₁ : v₁ ⟂ᵥ w) (h₂ : v₂ ⟂ᵥ w) : v₁ + v₂ ⟂ᵥ w 
goal: v₁ + v₂ ⟂ᵥ w

full_name: MeasureTheory.VectorMeasure.MutuallySingular.add_right
code: theorem add_right [T2Space M] [ContinuousAdd N] (h₁ : v ⟂ᵥ w₁) (h₂ : v ⟂ᵥ w₂) : v ⟂ᵥ w₁ + w₂ 
goal: v ⟂ᵥ w₁ + w₂

full_name: MeasureTheory.VectorMeasure.MutuallySingular.smul_right
code: theorem smul_right {R : Type*} [Semiring R] [DistribMulAction R N] [ContinuousConstSMul R N]
    (r : R) (h : v ⟂ᵥ w) : v ⟂ᵥ r • w 
goal: v ⟂ᵥ r • w

full_name: MeasureTheory.VectorMeasure.MutuallySingular.smul_left
code: theorem smul_left {R : Type*} [Semiring R] [DistribMulAction R M] [ContinuousConstSMul R M] (r : R)
    (h : v ⟂ᵥ w) : r • v ⟂ᵥ w 
goal: r • v ⟂ᵥ w

full_name: MeasureTheory.VectorMeasure.MutuallySingular.neg_left
code: theorem neg_left {M : Type*} [AddCommGroup M] [TopologicalSpace M] [TopologicalAddGroup M]
    {v : VectorMeasure α M} {w : VectorMeasure α N} (h : v ⟂ᵥ w) : -v ⟂ᵥ w 
goal: -v ⟂ᵥ w

full_name: MeasureTheory.VectorMeasure.MutuallySingular.neg_right
code: theorem neg_right {N : Type*} [AddCommGroup N] [TopologicalSpace N] [TopologicalAddGroup N]
    {v : VectorMeasure α M} {w : VectorMeasure α N} (h : v ⟂ᵥ w) : v ⟂ᵥ -w 
goal: v ⟂ᵥ -w

full_name: MeasureTheory.VectorMeasure.MutuallySingular.neg_left_iff
code: @[simp]
theorem neg_left_iff {M : Type*} [AddCommGroup M] [TopologicalSpace M] [TopologicalAddGroup M]
    {v : VectorMeasure α M} {w : VectorMeasure α N} : -v ⟂ᵥ w ↔ v ⟂ᵥ w 
goal: -v ⟂ᵥ w ↔ v ⟂ᵥ w

full_name: MeasureTheory.VectorMeasure.MutuallySingular.neg_right_iff
code: @[simp]
theorem neg_right_iff {N : Type*} [AddCommGroup N] [TopologicalSpace N] [TopologicalAddGroup N]
    {v : VectorMeasure α M} {w : VectorMeasure α N} : v ⟂ᵥ -w ↔ v ⟂ᵥ w 
goal: v ⟂ᵥ -w ↔ v ⟂ᵥ w

full_name: MeasureTheory.VectorMeasure.trim
code: /-- Restriction of a vector measure onto a sub-σ-algebra. -/
@[simps]
def trim {m n : MeasurableSpace α} (v : VectorMeasure α M) (hle : m ≤ n) :
    @VectorMeasure α m M _ _ 
goal: MeasureTheory.VectorMeasure α M

full_name: MeasureTheory.VectorMeasure.trim_apply
code: /-- Restriction of a vector measure onto a sub-σ-algebra. -/
@[simps]
def trim {m n : MeasurableSpace α} (v : VectorMeasure α M) (hle : m ≤ n) :
    @VectorMeasure α m M _ _ 
goal: ↑(v.trim hle) i = if MeasurableSet i then ↑v i else 0

full_name: MeasureTheory.VectorMeasure.trim_eq_self
code: theorem trim_eq_self : v.trim le_rfl = v 
goal: v.trim ⋯ = v

full_name: MeasureTheory.VectorMeasure.zero_trim
code: @[simp]
theorem zero_trim (hle : m ≤ n) : (0 : VectorMeasure α M).trim hle = 0 
goal: MeasureTheory.VectorMeasure.trim 0 hle = 0

full_name: MeasureTheory.VectorMeasure.trim_measurableSet_eq
code: theorem trim_measurableSet_eq (hle : m ≤ n) {i : Set α} (hi : MeasurableSet[m] i) :
    v.trim hle i = v i 
goal: ↑(v.trim hle) i = ↑v i

full_name: MeasureTheory.VectorMeasure.restrict_trim
code: theorem restrict_trim (hle : m ≤ n) {i : Set α} (hi : MeasurableSet[m] i) :
    @VectorMeasure.restrict α m M _ _ (v.trim hle) i = (v.restrict i).trim hle 
goal: (v.trim hle).restrict i = (v.restrict i).trim hle

full_name: MeasureTheory.SignedMeasure.toMeasureOfZeroLE'
code: /-- The underlying function for `SignedMeasure.toMeasureOfZeroLE`. -/
def toMeasureOfZeroLE' (s : SignedMeasure α) (i : Set α) (hi : 0 ≤[i] s) (j : Set α)
    (hj : MeasurableSet j) : ℝ≥0∞ 
goal: ℝ≥0∞

full_name: MeasureTheory.SignedMeasure.toMeasureOfZeroLE
code: /-- Given a signed measure `s` and a positive measurable set `i`, `toMeasureOfZeroLE`
provides the measure, mapping measurable sets `j` to `s (i ∩ j)`. -/
def toMeasureOfZeroLE (s : SignedMeasure α) (i : Set α) (hi₁ : MeasurableSet i) (hi₂ : 0 ≤[i] s) :
    Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.SignedMeasure.toMeasureOfZeroLE_apply
code: theorem toMeasureOfZeroLE_apply (hi : 0 ≤[i] s) (hi₁ : MeasurableSet i) (hj₁ : MeasurableSet j) :
    s.toMeasureOfZeroLE i hi₁ hi j = ((↑) : ℝ≥0 → ℝ≥0∞) ⟨s (i ∩ j), nonneg_of_zero_le_restrict
      s (zero_le_restrict_subset s hi₁ Set.inter_subset_left hi)⟩ 
goal: (s.toMeasureOfZeroLE i hi₁ hi) j = ↑⟨↑s (i ∩ j), ⋯⟩

full_name: MeasureTheory.SignedMeasure.toMeasureOfLEZero
code: /-- Given a signed measure `s` and a negative measurable set `i`, `toMeasureOfLEZero`
provides the measure, mapping measurable sets `j` to `-s (i ∩ j)`. -/
def toMeasureOfLEZero (s : SignedMeasure α) (i : Set α) (hi₁ : MeasurableSet i) (hi₂ : s ≤[i] 0) :
    Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.SignedMeasure.toMeasureOfLEZero_apply
code: theorem toMeasureOfLEZero_apply (hi : s ≤[i] 0) (hi₁ : MeasurableSet i) (hj₁ : MeasurableSet j) :
    s.toMeasureOfLEZero i hi₁ hi j = ((↑) : ℝ≥0 → ℝ≥0∞) ⟨-s (i ∩ j), neg_apply s (i ∩ j) ▸
      nonneg_of_zero_le_restrict _ (zero_le_restrict_subset _ hi₁ Set.inter_subset_left
      (@neg_zero (VectorMeasure α ℝ) _ ▸ neg_le_neg _ _ hi₁ hi))⟩ 
goal: (s.toMeasureOfLEZero i hi₁ hi) j = ↑⟨-↑s (i ∩ j), ⋯⟩

full_name: MeasureTheory.SignedMeasure.toMeasureOfZeroLE_finite
code: /-- `SignedMeasure.toMeasureOfZeroLE` is a finite measure. -/
instance toMeasureOfZeroLE_finite (hi : 0 ≤[i] s) (hi₁ : MeasurableSet i) :
    IsFiniteMeasure (s.toMeasureOfZeroLE i hi₁ hi) 
goal: MeasureTheory.IsFiniteMeasure (s.toMeasureOfZeroLE i hi₁ hi)

full_name: MeasureTheory.SignedMeasure.toMeasureOfLEZero_finite
code: /-- `SignedMeasure.toMeasureOfLEZero` is a finite measure. -/
instance toMeasureOfLEZero_finite (hi : s ≤[i] 0) (hi₁ : MeasurableSet i) :
    IsFiniteMeasure (s.toMeasureOfLEZero i hi₁ hi) 
goal: MeasureTheory.IsFiniteMeasure (s.toMeasureOfLEZero i hi₁ hi)

full_name: MeasureTheory.SignedMeasure.toMeasureOfZeroLE_toSignedMeasure
code: theorem toMeasureOfZeroLE_toSignedMeasure (hs : 0 ≤[Set.univ] s) :
    (s.toMeasureOfZeroLE Set.univ MeasurableSet.univ hs).toSignedMeasure = s 
goal: (s.toMeasureOfZeroLE Set.univ ⋯ hs).toSignedMeasure = s

full_name: MeasureTheory.SignedMeasure.toMeasureOfLEZero_toSignedMeasure
code: theorem toMeasureOfLEZero_toSignedMeasure (hs : s ≤[Set.univ] 0) :
    (s.toMeasureOfLEZero Set.univ MeasurableSet.univ hs).toSignedMeasure = -s 
goal: (s.toMeasureOfLEZero Set.univ ⋯ hs).toSignedMeasure = -s

full_name: MeasureTheory.Measure.zero_le_toSignedMeasure
code: theorem zero_le_toSignedMeasure : 0 ≤ μ.toSignedMeasure 
goal: 0 ≤ μ.toSignedMeasure

full_name: MeasureTheory.Measure.toSignedMeasure_toMeasureOfZeroLE
code: theorem toSignedMeasure_toMeasureOfZeroLE :
    μ.toSignedMeasure.toMeasureOfZeroLE Set.univ MeasurableSet.univ
      ((le_restrict_univ_iff_le _ _).2 (zero_le_toSignedMeasure μ)) = μ 
goal: μ.toSignedMeasure.toMeasureOfZeroLE Set.univ ⋯ ⋯ = μ