Theorem: MeasureTheory.SimpleFunc.map_setToSimpleFunc
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: have T_empty : T ∅ = 0 := h_add.map_empty_eq_zero
state_before: α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
⊢ setToSimpleFunc T (map g f) = ∑ x in SimpleFunc.range f, ↑(T (↑f ⁻¹' {x})) (g x)

tactic: have hfp : ∀ x ∈ f.range, x ≠ 0 → μ (f ⁻¹' {x}) ≠ ∞ := fun x _ hx0 =>
  (measure_preimage_lt_top_of_integrable f hf hx0).ne
state_before: α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
⊢ setToSimpleFunc T (map g f) = ∑ x in SimpleFunc.range f, ↑(T (↑f ⁻¹' {x})) (g x)

tactic: simp only [setToSimpleFunc, range_map]
state_before: α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
⊢ setToSimpleFunc T (map g f) = ∑ x in SimpleFunc.range f, ↑(T (↑f ⁻¹' {x})) (g x)

tactic: refine' Finset.sum_image' _ fun b hb => _
state_before: α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
⊢ ∑ x in Finset.image g (SimpleFunc.range f), ↑(T (↑(map g f) ⁻¹' {x})) x =
    ∑ x in SimpleFunc.range f, ↑(T (↑f ⁻¹' {x})) (g x)

tactic: rcases mem_range.1 hb with ⟨a, rfl⟩
state_before: α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
b : G
hb : b ∈ SimpleFunc.range f
⊢ ↑(T (↑(map g f) ⁻¹' {g b})) (g b) = ∑ x in filter (fun c' => g c' = g b) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: by_cases h0 : g (f a) = 0
state_before: case intro
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
⊢ ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ∑ x in filter (fun c' => g c' = g (↑f a)) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: have h_left_eq :
  T (map g f ⁻¹' {g (f a)}) (g (f a)) =
    T (f ⁻¹' (f.range.filter fun b => g b = g (f a))) (g (f a)) :=
  by congr; rw [map_preimage_singleton]
state_before: case neg
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
⊢ ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ∑ x in filter (fun c' => g c' = g (↑f a)) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: rw [h_left_eq]
state_before: case neg
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
⊢ ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ∑ x in filter (fun c' => g c' = g (↑f a)) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: have h_left_eq' :
  T (f ⁻¹' (filter (fun b : G => g b = g (f a)) f.range)) (g (f a)) =
    T (⋃ y ∈ filter (fun b : G => g b = g (f a)) f.range, f ⁻¹' {y}) (g (f a)) :=
  by congr; rw [← Finset.set_biUnion_preimage_singleton]
state_before: case neg
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
⊢ ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ∑ x in filter (fun c' => g c' = g (↑f a)) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: rw [h_left_eq']
state_before: case neg
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
⊢ ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ∑ x in filter (fun c' => g c' = g (↑f a)) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: rw [h_add.map_iUnion_fin_meas_set_eq_sum T T_empty]
state_before: case neg
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
⊢ ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a)) =
    ∑ x in filter (fun c' => g c' = g (↑f a)) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: simp_rw [h0]
state_before: case pos
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : g (↑f a) = 0
⊢ ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ∑ x in filter (fun c' => g c' = g (↑f a)) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: rw [ContinuousLinearMap.map_zero, Finset.sum_eq_zero fun x hx => ?_]
state_before: case pos
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : g (↑f a) = 0
⊢ ↑(T (↑(map g f) ⁻¹' {0})) 0 = ∑ x in filter (fun c' => g c' = 0) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: rw [mem_filter] at hx
state_before: α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : g (↑f a) = 0
x : G
hx : x ∈ filter (fun c' => g c' = 0) (SimpleFunc.range f)
⊢ ↑(T (↑f ⁻¹' {x})) (g x) = 0

tactic: rw [hx.2, ContinuousLinearMap.map_zero]
state_before: α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : g (↑f a) = 0
x : G
hx : x ∈ SimpleFunc.range f ∧ g x = 0
⊢ ↑(T (↑f ⁻¹' {x})) (g x) = 0

tactic: congr
state_before: α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
⊢ ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))

tactic: rw [map_preimage_singleton]
state_before: case e_a.e_a
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
⊢ ↑(map g f) ⁻¹' {g (↑f a)} = ↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f))

tactic: congr
state_before: α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
⊢ ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))

tactic: rw [← Finset.set_biUnion_preimage_singleton]
state_before: case e_a.e_a
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
⊢ ↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)) =
    ⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y}

tactic: simp only [sum_apply, ContinuousLinearMap.coe_sum']
state_before: case neg
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
⊢ ↑(∑ i in filter (fun b => g b = g (↑f a)) (SimpleFunc.range f), T (↑f ⁻¹' {i})) (g (↑f a)) =
    ∑ x in filter (fun c' => g c' = g (↑f a)) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: refine' Finset.sum_congr rfl fun x hx => _
state_before: case neg
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
⊢ ∑ c in filter (fun b => g b = g (↑f a)) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {c})) (g (↑f a)) =
    ∑ x in filter (fun c' => g c' = g (↑f a)) (SimpleFunc.range f), ↑(T (↑f ⁻¹' {x})) (g x)

tactic: rw [mem_filter] at hx
state_before: case neg
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
x : G
hx : x ∈ filter (fun c' => g c' = g (↑f a)) (SimpleFunc.range f)
⊢ ↑(T (↑f ⁻¹' {x})) (g (↑f a)) = ↑(T (↑f ⁻¹' {x})) (g x)

tactic: rw [hx.2]
state_before: case neg
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
x : G
hx : x ∈ SimpleFunc.range f ∧ g x = g (↑f a)
⊢ ↑(T (↑f ⁻¹' {x})) (g (↑f a)) = ↑(T (↑f ⁻¹' {x})) (g x)

tactic: exact fun i => measurableSet_fiber _ _
state_before: case neg.hS_meas
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
⊢ ∀ (i : G), MeasurableSet (↑f ⁻¹' {i})

tactic: intro i hi
state_before: case neg.hSp
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
⊢ ∀ (i : G), i ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f) → ↑↑μ (↑f ⁻¹' {i}) ≠ ⊤

tactic: rw [mem_filter] at hi
state_before: case neg.hSp
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
i : G
hi : i ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
⊢ ↑↑μ (↑f ⁻¹' {i}) ≠ ⊤

tactic: refine' hfp i hi.1 fun hi0 => _
state_before: case neg.hSp
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
i : G
hi : i ∈ SimpleFunc.range f ∧ g i = g (↑f a)
⊢ ↑↑μ (↑f ⁻¹' {i}) ≠ ⊤

tactic: rw [hi0, hg] at hi
state_before: case neg.hSp
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
i : G
hi : i ∈ SimpleFunc.range f ∧ g i = g (↑f a)
hi0 : i = 0
⊢ False

tactic: exact h0 hi.2.symm
state_before: case neg.hSp
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
i : G
hi : 0 ∈ SimpleFunc.range f ∧ 0 = g (↑f a)
hi0 : i = 0
⊢ False

tactic: intro i _j hi _ hij
state_before: case neg.h_disj
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
⊢ ∀ (i : G),
    i ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f) →
      ∀ (j : G), j ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f) → i ≠ j → Disjoint (↑f ⁻¹' {i}) (↑f ⁻¹' {j})

tactic: rw [Set.disjoint_iff]
state_before: case neg.h_disj
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
i : G
_j : i ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
hi : G
a✝ : hi ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
hij : i ≠ hi
⊢ Disjoint (↑f ⁻¹' {i}) (↑f ⁻¹' {hi})

tactic: intro x hx
state_before: case neg.h_disj
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
i : G
_j : i ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
hi : G
a✝ : hi ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
hij : i ≠ hi
⊢ ↑f ⁻¹' {i} ∩ ↑f ⁻¹' {hi} ⊆ ∅

tactic: rw [Set.mem_inter_iff, Set.mem_preimage, Set.mem_preimage, Set.mem_singleton_iff,
  Set.mem_singleton_iff] at hx
state_before: case neg.h_disj
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
i : G
_j : i ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
hi : G
a✝ : hi ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
hij : i ≠ hi
x : α
hx : x ∈ ↑f ⁻¹' {i} ∩ ↑f ⁻¹' {hi}
⊢ x ∈ ∅

tactic: rw [← hx.1, ← hx.2] at hij
state_before: case neg.h_disj
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
i : G
_j : i ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
hi : G
a✝ : hi ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
hij : i ≠ hi
x : α
hx : ↑f x = i ∧ ↑f x = hi
⊢ x ∈ ∅

tactic: exact absurd rfl hij
state_before: case neg.h_disj
α : Type u_1
E : Type ?u.168928
F : Type u_2
F' : Type u_3
G : Type u_4
𝕜 : Type ?u.168940
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → F →L[ℝ] F'
h_add : FinMeasAdditive μ T
f : α →ₛ G
hf : Integrable ↑f
g : G → F
hg : g 0 = 0
T_empty : T ∅ = 0
hfp : ∀ (x : G), x ∈ SimpleFunc.range f → x ≠ 0 → ↑↑μ (↑f ⁻¹' {x}) ≠ ⊤
a : α
hb : ↑f a ∈ SimpleFunc.range f
h0 : ¬g (↑f a) = 0
h_left_eq :
  ↑(T (↑(map g f) ⁻¹' {g (↑f a)})) (g (↑f a)) =
    ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a))
h_left_eq' :
  ↑(T (↑f ⁻¹' ↑(filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)))) (g (↑f a)) =
    ↑(T (⋃ (y : G) (_ : y ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)), ↑f ⁻¹' {y})) (g (↑f a))
i : G
_j : i ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
hi : G
a✝ : hi ∈ filter (fun b => g b = g (↑f a)) (SimpleFunc.range f)
x : α
hij : ↑f x ≠ ↑f x
hx : ↑f x = i ∧ ↑f x = hi
⊢ x ∈ ∅