l3lab/ntp-mathlib huggingface dataset:
/-- 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 where
  measureOf' s := f (v s)
  empty' := by simp only; rw [empty, AddMonoidHom.map_zero]
  not_measurable' i hi := by 

Proof state:
α : Type u_1
β : Type u_2
m inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
v✝ : VectorMeasure α M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
v : VectorMeasure α M
f : M →+ N
hf : Continuous ⇑f
i : Set α
hi : ¬MeasurableSet i
⊢ (fun s => f (↑v s)) i = 0

Next tactic:
simp only
/-- 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 where
  measureOf' s := f (v s)
  empty' := by simp only; rw [empty, AddMonoidHom.map_zero]
  not_measurable' i hi := by simp only; 

Proof state:
α : Type u_1
β : Type u_2
m inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
v✝ : VectorMeasure α M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
v : VectorMeasure α M
f : M →+ N
hf : Continuous ⇑f
i : Set α
hi : ¬MeasurableSet i
⊢ f (↑v i) = 0

Next tactic:
rw [not_measurable v hi, AddMonoidHom.map_zero]
@[simp]
theorem mapRange_id : v.mapRange (AddMonoidHom.id M) continuous_id = v := by
  

Proof state:
α : Type u_1
β : Type u_2
m inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
v : VectorMeasure α M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
⊢ mapRange v (AddMonoidHom.id M) (_ : Continuous id) = v

Next tactic:
ext
@[simp]
theorem mapRange_id : v.mapRange (AddMonoidHom.id M) continuous_id = v := by
  ext
  

Proof state:
case h
α : Type u_1
β : Type u_2
m inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
v : VectorMeasure α M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
i✝ : Set α
a✝ : MeasurableSet i✝
⊢ ↑(mapRange v (AddMonoidHom.id M) (_ : Continuous id)) i✝ = ↑v i✝

Next tactic:
rfl
@[simp]
theorem mapRange_zero {f : M →+ N} (hf : Continuous f) :
    mapRange (0 : VectorMeasure α M) f hf = 0 := by
  

Proof state:
α : Type u_1
β : Type u_2
m inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
v : VectorMeasure α M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
f : M →+ N
hf : Continuous ⇑f
⊢ mapRange 0 f hf = 0

Next tactic:
ext
@[simp]
theorem mapRange_zero {f : M →+ N} (hf : Continuous f) :
    mapRange (0 : VectorMeasure α M) f hf = 0 := by
  ext
  

Proof state:
case h
α : Type u_1
β : Type u_2
m inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
v : VectorMeasure α M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
f : M →+ N
hf : Continuous ⇑f
i✝ : Set α
a✝ : MeasurableSet i✝
⊢ ↑(mapRange 0 f hf) i✝ = ↑0 i✝

Next tactic:
simp
@[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 := by
  

Proof state:
α : Type u_1
β : Type u_2
m inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace β
M : Type u_3
inst✝⁵ : AddCommMonoid M
inst✝⁴ : TopologicalSpace M
v✝ : VectorMeasure α M
N : Type u_4
inst✝³ : AddCommMonoid N
inst✝² : TopologicalSpace N
inst✝¹ : ContinuousAdd M
inst✝ : ContinuousAdd N
v w : VectorMeasure α M
f : M →+ N
hf : Continuous ⇑f
⊢ mapRange (v + w) f hf = mapRange v f hf + mapRange w f hf

Next tactic:
ext
@[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 := by
  ext
  

Proof state:
case h
α : Type u_1
β : Type u_2
m inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace β
M : Type u_3
inst✝⁵ : AddCommMonoid M
inst✝⁴ : TopologicalSpace M
v✝ : VectorMeasure α M
N : Type u_4
inst✝³ : AddCommMonoid N
inst✝² : TopologicalSpace N
inst✝¹ : ContinuousAdd M
inst✝ : ContinuousAdd N
v w : VectorMeasure α M
f : M →+ N
hf : Continuous ⇑f
i✝ : Set α
a✝ : MeasurableSet i✝
⊢ ↑(mapRange (v + w) f hf) i✝ = ↑(mapRange v f hf + mapRange w f hf) i✝

Next tactic:
simp
/-- 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 where
  toFun v := v.mapRange f.toAddMonoidHom hf
  map_add' _ _ := mapRange_add hf
  map_smul' := by
    

Proof state:
α : Type u_1
β : Type u_2
m inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace β
M : Type u_3
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : TopologicalSpace M
v : VectorMeasure α M
N : Type u_4
inst✝⁸ : AddCommMonoid N
inst✝⁷ : TopologicalSpace N
R : Type u_5
inst✝⁶ : Semiring R
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : ContinuousAdd M
inst✝² : ContinuousAdd N
inst✝¹ : ContinuousConstSMul R M
inst✝ : ContinuousConstSMul R N
f : M →ₗ[R] N
hf : Continuous ⇑f
⊢ ∀ (r : R) (x : VectorMeasure α M),
    AddHom.toFun
        { toFun := fun v => mapRange v (LinearMap.toAddMonoidHom f) hf,
          map_add' :=
            (_ :
              ∀ (x x_1 : VectorMeasure α M),
                mapRange (x + x_1) (LinearMap.toAddMonoidHom f) hf =
                  mapRange x (LinearMap.toAddMonoidHom f) hf + mapRange x_1 (LinearMap.toAddMonoidHom f) hf) }
        (r • x) =
      (RingHom.id R) r •
        AddHom.toFun
          { toFun := fun v => mapRange v (LinearMap.toAddMonoidHom f) hf,
            map_add' :=
              (_ :
                ∀ (x x_1 : VectorMeasure α M),
                  mapRange (x + x_1) (LinearMap.toAddMonoidHom f) hf =
                    mapRange x (LinearMap.toAddMonoidHom f) hf + mapRange x_1 (LinearMap.toAddMonoidHom f) hf) }
          x

Next tactic:
intros
/-- 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 where
  toFun v := v.mapRange f.toAddMonoidHom hf
  map_add' _ _ := mapRange_add hf
  map_smul' := by
    intros
    

Proof state:
α : Type u_1
β : Type u_2
m inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace β
M : Type u_3
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : TopologicalSpace M
v : VectorMeasure α M
N : Type u_4
inst✝⁸ : AddCommMonoid N
inst✝⁷ : TopologicalSpace N
R : Type u_5
inst✝⁶ : Semiring R
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : ContinuousAdd M
inst✝² : ContinuousAdd N
inst✝¹ : ContinuousConstSMul R M
inst✝ : ContinuousConstSMul R N
f : M →ₗ[R] N
hf : Continuous ⇑f
r✝ : R
x✝ : VectorMeasure α M
⊢ AddHom.toFun
      { toFun := fun v => mapRange v (LinearMap.toAddMonoidHom f) hf,
        map_add' :=
          (_ :
            ∀ (x x_1 : VectorMeasure α M),
              mapRange (x + x_1) (LinearMap.toAddMonoidHom f) hf =
                mapRange x (LinearMap.toAddMonoidHom f) hf + mapRange x_1 (LinearMap.toAddMonoidHom f) hf) }
      (r✝ • x✝) =
    (RingHom.id R) r✝ •
      AddHom.toFun
        { toFun := fun v => mapRange v (LinearMap.toAddMonoidHom f) hf,
          map_add' :=
            (_ :
              ∀ (x x_1 : VectorMeasure α M),
                mapRange (x + x_1) (LinearMap.toAddMonoidHom f) hf =
                  mapRange x (LinearMap.toAddMonoidHom f) hf + mapRange x_1 (LinearMap.toAddMonoidHom f) hf) }
        x✝

Next tactic:
ext
/-- 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 where
  toFun v := v.mapRange f.toAddMonoidHom hf
  map_add' _ _ := mapRange_add hf
  map_smul' := by
    intros
    ext
    

Proof state:
case h
α : Type u_1
β : Type u_2
m inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace β
M : Type u_3
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : TopologicalSpace M
v : VectorMeasure α M
N : Type u_4
inst✝⁸ : AddCommMonoid N
inst✝⁷ : TopologicalSpace N
R : Type u_5
inst✝⁶ : Semiring R
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : ContinuousAdd M
inst✝² : ContinuousAdd N
inst✝¹ : ContinuousConstSMul R M
inst✝ : ContinuousConstSMul R N
f : M →ₗ[R] N
hf : Continuous ⇑f
r✝ : R
x✝ : VectorMeasure α M
i✝ : Set α
a✝ : MeasurableSet i✝
⊢ ↑(AddHom.toFun
          { toFun := fun v => mapRange v (LinearMap.toAddMonoidHom f) hf,
            map_add' :=
              (_ :
                ∀ (x x_1 : VectorMeasure α M),
                  mapRange (x + x_1) (LinearMap.toAddMonoidHom f) hf =
                    mapRange x (LinearMap.toAddMonoidHom f) hf + mapRange x_1 (LinearMap.toAddMonoidHom f) hf) }
          (r✝ • x✝))
      i✝ =
    ↑((RingHom.id R) r✝ •
          AddHom.toFun
            { toFun := fun v => mapRange v (LinearMap.toAddMonoidHom f) hf,
              map_add' :=
                (_ :
                  ∀ (x x_1 : VectorMeasure α M),
                    mapRange (x + x_1) (LinearMap.toAddMonoidHom f) hf =
                      mapRange x (LinearMap.toAddMonoidHom f) hf + mapRange x_1 (LinearMap.toAddMonoidHom f) hf) }
            x✝)
      i✝

Next tactic:
simp
/-- The restriction of a vector measure on some set. -/
def restrict (v : VectorMeasure α M) (i : Set α) : VectorMeasure α M :=
  if hi : MeasurableSet i then
    { measureOf' := fun s => if MeasurableSet s then v (s ∩ i) else 0
      empty' := by 

Proof state:
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v✝ v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ (fun s => if MeasurableSet s then ↑v (s ∩ i) else 0) ∅ = 0

Next tactic:
simp
/-- The restriction of a vector measure on some set. -/
def restrict (v : VectorMeasure α M) (i : Set α) : VectorMeasure α M :=
  if hi : MeasurableSet i then
    { measureOf' := fun s => if MeasurableSet s then v (s ∩ i) else 0
      empty' := by simp
      not_measurable' := fun i hi => if_neg hi
      m_iUnion' := by
        

Proof state:
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v✝ v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ ∀ ⦃f : ℕ → Set α⦄,
    (∀ (i : ℕ), MeasurableSet (f i)) →
      Pairwise (Disjoint on f) →
        HasSum (fun i_1 => (fun s => if MeasurableSet s then ↑v (s ∩ i) else 0) (f i_1))
          ((fun s => if MeasurableSet s then ↑v (s ∩ i) else 0) (⋃ i, f i))

Next tactic:
intro f hf₁ hf₂
/-- The restriction of a vector measure on some set. -/
def restrict (v : VectorMeasure α M) (i : Set α) : VectorMeasure α M :=
  if hi : MeasurableSet i then
    { measureOf' := fun s => if MeasurableSet s then v (s ∩ i) else 0
      empty' := by simp
      not_measurable' := fun i hi => if_neg hi
      m_iUnion' := by
        intro f hf₁ hf₂
        

Proof state:
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v✝ v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ HasSum (fun i_1 => (fun s => if MeasurableSet s then ↑v (s ∩ i) else 0) (f i_1))
    ((fun s => if MeasurableSet s then ↑v (s ∩ i) else 0) (⋃ i, f i))

Next tactic:
simp only
/-- The restriction of a vector measure on some set. -/
def restrict (v : VectorMeasure α M) (i : Set α) : VectorMeasure α M :=
  if hi : MeasurableSet i then
    { measureOf' := fun s => if MeasurableSet s then v (s ∩ i) else 0
      empty' := by simp
      not_measurable' := fun i hi => if_neg hi
      m_iUnion' := by
        intro f hf₁ hf₂
        simp only
        

Proof state:
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v✝ v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ HasSum (fun i_1 => if MeasurableSet (f i_1) then ↑v (f i_1 ∩ i) else 0)
    (if MeasurableSet (⋃ i, f i) then ↑v ((⋃ i, f i) ∩ i) else 0)

Next tactic:
convert v.m_iUnion (fun n => (hf₁ n).inter hi)
            (hf₂.mono fun i j => Disjoint.mono inf_le_left inf_le_left)
/-- The restriction of a vector measure on some set. -/
def restrict (v : VectorMeasure α M) (i : Set α) : VectorMeasure α M :=
  if hi : MeasurableSet i then
    { measureOf' := fun s => if MeasurableSet s then v (s ∩ i) else 0
      empty' := by simp
      not_measurable' := fun i hi => if_neg hi
      m_iUnion' := by
        intro f hf₁ hf₂
        simp only
        convert v.m_iUnion (fun n => (hf₁ n).inter hi)
            (hf₂.mono fun i j => Disjoint.mono inf_le_left inf_le_left)
        · 

Proof state:
case h.e'_5.h
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v✝ v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
x✝ : ℕ
⊢ (if MeasurableSet (f x✝) then ↑v (f x✝ ∩ i) else 0) = ↑v (f x✝ ∩ i)

Next tactic:
rw [if_pos (hf₁ _)]
/-- The restriction of a vector measure on some set. -/
def restrict (v : VectorMeasure α M) (i : Set α) : VectorMeasure α M :=
  if hi : MeasurableSet i then
    { measureOf' := fun s => if MeasurableSet s then v (s ∩ i) else 0
      empty' := by simp
      not_measurable' := fun i hi => if_neg hi
      m_iUnion' := by
        intro f hf₁ hf₂
        simp only
        convert v.m_iUnion (fun n => (hf₁ n).inter hi)
            (hf₂.mono fun i j => Disjoint.mono inf_le_left inf_le_left)
        · rw [if_pos (hf₁ _)]
        · 

Proof state:
case h.e'_6
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v✝ v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ (if MeasurableSet (⋃ i, f i) then ↑v ((⋃ i, f i) ∩ i) else 0) = ↑v (⋃ i_1, f i_1 ∩ i)

Next tactic:
rw [Set.iUnion_inter, if_pos (MeasurableSet.iUnion hf₁)]
theorem restrict_apply {i : Set α} (hi : MeasurableSet i) {j : Set α} (hj : MeasurableSet j) :
    v.restrict i j = v (j ∩ i) := by
  

Proof state:
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
j : Set α
hj : MeasurableSet j
⊢ ↑(restrict v i) j = ↑v (j ∩ i)

Next tactic:
rw [restrict, dif_pos hi]
theorem restrict_apply {i : Set α} (hi : MeasurableSet i) {j : Set α} (hj : MeasurableSet j) :
    v.restrict i j = v (j ∩ i) := by
  rw [restrict, dif_pos hi]
  

Proof state:
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
j : Set α
hj : MeasurableSet j
⊢ ↑{ measureOf' := fun s => if MeasurableSet s then ↑v (s ∩ i) else 0,
          empty' := (_ : (if MeasurableSet ∅ then ↑v (∅ ∩ i) else 0) = 0),
          not_measurable' :=
            (_ : ∀ (i_1 : Set α), ¬MeasurableSet i_1 → (if MeasurableSet i_1 then ↑v (i_1 ∩ i) else 0) = 0),
          m_iUnion' :=
            (_ :
              ∀ ⦃f : ℕ → Set α⦄,
                (∀ (i : ℕ), MeasurableSet (f i)) →
                  Pairwise (Disjoint on f) →
                    HasSum (fun i_1 => (fun s => if MeasurableSet s then ↑v (s ∩ i) else 0) (f i_1))
                      ((fun s => if MeasurableSet s then ↑v (s ∩ i) else 0) (⋃ i, f i))) }
      j =
    ↑v (j ∩ i)

Next tactic:
exact if_pos hj
theorem restrict_eq_self {i : Set α} (hi : MeasurableSet i) {j : Set α} (hj : MeasurableSet j)
    (hij : j ⊆ i) : v.restrict i j = v j := by
  

Proof state:
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
j : Set α
hj : MeasurableSet j
hij : j ⊆ i
⊢ ↑(restrict v i) j = ↑v j

Next tactic:
rw [restrict_apply v hi hj, Set.inter_eq_left.2 hij]
@[simp]
theorem restrict_empty : v.restrict ∅ = 0 :=
  ext fun i hi => by
    

Proof state:
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ ↑(restrict v ∅) i = ↑0 i

Next tactic:
rw [restrict_apply v MeasurableSet.empty hi, Set.inter_empty, v.empty, zero_apply]
@[simp]
theorem restrict_univ : v.restrict Set.univ = v :=
  ext fun i hi => by 

Proof state:
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ ↑(restrict v univ) i = ↑v i

Next tactic:
rw [restrict_apply v MeasurableSet.univ hi, Set.inter_univ]
@[simp]
theorem restrict_zero {i : Set α} : (0 : VectorMeasure α M).restrict i = 0 := by
  

Proof state:
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
⊢ restrict 0 i = 0

Next tactic:
by_cases hi : MeasurableSet i
@[simp]
theorem restrict_zero {i : Set α} : (0 : VectorMeasure α M).restrict i = 0 := by
  by_cases hi : MeasurableSet i
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ restrict 0 i = 0

Next tactic:
ext j hj
@[simp]
theorem restrict_zero {i : Set α} : (0 : VectorMeasure α M).restrict i = 0 := by
  by_cases hi : MeasurableSet i
  · ext j hj
    

Proof state:
case pos.h
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
j : Set α
hj : MeasurableSet j
⊢ ↑(restrict 0 i) j = ↑0 j

Next tactic:
rw [restrict_apply 0 hi hj, zero_apply, zero_apply]
@[simp]
theorem restrict_zero {i : Set α} : (0 : VectorMeasure α M).restrict i = 0 := by
  by_cases hi : MeasurableSet i
  · ext j hj
    rw [restrict_apply 0 hi hj, zero_apply, zero_apply]
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : ¬MeasurableSet i
⊢ restrict 0 i = 0

Next tactic:
exact dif_neg hi
theorem map_add (v w : VectorMeasure α M) (f : α → β) : (v + w).map f = v.map f + w.map f := by
  

Proof state:
α : Type u_1
β : Type u_2
m inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
v✝ : VectorMeasure α M
inst✝ : ContinuousAdd M
v w : VectorMeasure α M
f : α → β
⊢ map (v + w) f = map v f + map w f

Next tactic:
by_cases hf : Measurable f
theorem map_add (v w : VectorMeasure α M) (f : α → β) : (v + w).map f = v.map f + w.map f := by
  by_cases hf : Measurable f
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
m inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
v✝ : VectorMeasure α M
inst✝ : ContinuousAdd M
v w : VectorMeasure α M
f : α → β
hf : Measurable f
⊢ map (v + w) f = map v f + map w f

Next tactic:
ext i hi
theorem map_add (v w : VectorMeasure α M) (f : α → β) : (v + w).map f = v.map f + w.map f := by
  by_cases hf : Measurable f
  · ext i hi
    

Proof state:
case pos.h
α : Type u_1
β : Type u_2
m inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
v✝ : VectorMeasure α M
inst✝ : ContinuousAdd M
v w : VectorMeasure α M
f : α → β
hf : Measurable f
i : Set β
hi : MeasurableSet i
⊢ ↑(map (v + w) f) i = ↑(map v f + map w f) i

Next tactic:
simp [map_apply _ hf hi]
theorem map_add (v w : VectorMeasure α M) (f : α → β) : (v + w).map f = v.map f + w.map f := by
  by_cases hf : Measurable f
  · ext i hi
    simp [map_apply _ hf hi]
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
m inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
v✝ : VectorMeasure α M
inst✝ : ContinuousAdd M
v w : VectorMeasure α M
f : α → β
hf : ¬Measurable f
⊢ map (v + w) f = map v f + map w f

Next tactic:
simp [map, dif_neg hf]
theorem restrict_add (v w : VectorMeasure α M) (i : Set α) :
    (v + w).restrict i = v.restrict i + w.restrict i := by
  

Proof state:
α : Type u_1
β : Type u_2
m inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
v✝ : VectorMeasure α M
inst✝ : ContinuousAdd M
v w : VectorMeasure α M
i : Set α
⊢ restrict (v + w) i = restrict v i + restrict w i

Next tactic:
by_cases hi : MeasurableSet i
theorem restrict_add (v w : VectorMeasure α M) (i : Set α) :
    (v + w).restrict i = v.restrict i + w.restrict i := by
  by_cases hi : MeasurableSet i
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
m inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
v✝ : VectorMeasure α M
inst✝ : ContinuousAdd M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ restrict (v + w) i = restrict v i + restrict w i

Next tactic:
ext j hj
theorem restrict_add (v w : VectorMeasure α M) (i : Set α) :
    (v + w).restrict i = v.restrict i + w.restrict i := by
  by_cases hi : MeasurableSet i
  · ext j hj
    

Proof state:
case pos.h
α : Type u_1
β : Type u_2
m inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
v✝ : VectorMeasure α M
inst✝ : ContinuousAdd M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
j : Set α
hj : MeasurableSet j
⊢ ↑(restrict (v + w) i) j = ↑(restrict v i + restrict w i) j

Next tactic:
simp [restrict_apply _ hi hj]
theorem restrict_add (v w : VectorMeasure α M) (i : Set α) :
    (v + w).restrict i = v.restrict i + w.restrict i := by
  by_cases hi : MeasurableSet i
  · ext j hj
    simp [restrict_apply _ hi hj]
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
m inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
v✝ : VectorMeasure α M
inst✝ : ContinuousAdd M
v w : VectorMeasure α M
i : Set α
hi : ¬MeasurableSet i
⊢ restrict (v + w) i = restrict v i + restrict w i

Next tactic:
simp [restrict_not_measurable _ hi]
@[simp]
theorem map_smul {v : VectorMeasure α M} {f : α → β} (c : R) : (c • v).map f = c • v.map f := by
  

Proof state:
α : Type u_1
β : Type u_2
m : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
M : Type u_3
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
R : Type u_4
inst✝² : Semiring R
inst✝¹ : DistribMulAction R M
inst✝ : ContinuousConstSMul R M
v : VectorMeasure α M
f : α → β
c : R
⊢ map (c • v) f = c • map v f

Next tactic:
by_cases hf : Measurable f
@[simp]
theorem map_smul {v : VectorMeasure α M} {f : α → β} (c : R) : (c • v).map f = c • v.map f := by
  by_cases hf : Measurable f
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
inst✝⁵ : MeasurableSpace β
M : Type u_3
inst✝⁴ : AddCommMonoid M
inst✝³ : TopologicalSpace M
R : Type u_4
inst✝² : Semiring R
inst✝¹ : DistribMulAction R M
inst✝ : ContinuousConstSMul R M
v : VectorMeasure α M
f : α → β
c : R
hf : Measurable f
⊢ map (c • v) f = c • map v f

Next tactic:
ext i hi