l3lab/ntp-mathlib huggingface dataset:
theorem set_integral_withDensity_eq_set_integral_smul₀ {f : α → ℝ≥0} {s : Set α}
    (hf : AEMeasurable f (μ.restrict s)) (g : α → E) (hs : MeasurableSet s) :
    ∫ a in s, g a ∂μ.withDensity (fun x => f x) = ∫ a in s, f a • g a ∂μ := by
  

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁷ : MeasurableSpace α
ι : Type u_5
inst✝⁶ : NormedAddCommGroup E
μ : Measure α
𝕜 : Type u_6
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℝ F
f : α → ℝ≥0
s : Set α
hf : AEMeasurable f
g : α → E
hs : MeasurableSet s
⊢ (∫ (a : α) in s, g a ∂Measure.withDensity μ fun x => ↑(f x)) = ∫ (a : α) in s, f a • g a ∂μ

Next tactic:
rw [restrict_withDensity hs, integral_withDensity_eq_integral_smul₀ hf]
theorem set_integral_withDensity_eq_set_integral_smul₀' [SFinite μ] {f : α → ℝ≥0} (s : Set α)
    (hf : AEMeasurable f (μ.restrict s)) (g : α → E)  :
    ∫ a in s, g a ∂μ.withDensity (fun x => f x) = ∫ a in s, f a • g a ∂μ := by
  

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁸ : MeasurableSpace α
ι : Type u_5
inst✝⁷ : NormedAddCommGroup E
μ : Measure α
𝕜 : Type u_6
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedSpace ℝ F
inst✝ : SFinite μ
f : α → ℝ≥0
s : Set α
hf : AEMeasurable f
g : α → E
⊢ (∫ (a : α) in s, g a ∂Measure.withDensity μ fun x => ↑(f x)) = ∫ (a : α) in s, f a • g a ∂μ

Next tactic:
rw [restrict_withDensity' s, integral_withDensity_eq_integral_smul₀ hf]
theorem measure_le_lintegral_thickenedIndicatorAux (μ : Measure α) {E : Set α}
    (E_mble : MeasurableSet E) (δ : ℝ) : μ E ≤ ∫⁻ a, (thickenedIndicatorAux δ E a : ℝ≥0∞) ∂μ := by
  

Proof state:
α : Type u_1
β : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
ι : Type u_5
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
⊢ ↑↑μ E ≤ ∫⁻ (a : α), thickenedIndicatorAux δ E a ∂μ

Next tactic:
convert_to lintegral μ (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ lintegral μ (thickenedIndicatorAux δ E)
theorem measure_le_lintegral_thickenedIndicatorAux (μ : Measure α) {E : Set α}
    (E_mble : MeasurableSet E) (δ : ℝ) : μ E ≤ ∫⁻ a, (thickenedIndicatorAux δ E a : ℝ≥0∞) ∂μ := by
  convert_to lintegral μ (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ lintegral μ (thickenedIndicatorAux δ E)
  · 

Proof state:
case h.e'_3
α : Type u_1
β : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
ι : Type u_5
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
⊢ ↑↑μ E = lintegral μ (indicator E fun x => 1)

Next tactic:
rw [lintegral_indicator _ E_mble]
theorem measure_le_lintegral_thickenedIndicatorAux (μ : Measure α) {E : Set α}
    (E_mble : MeasurableSet E) (δ : ℝ) : μ E ≤ ∫⁻ a, (thickenedIndicatorAux δ E a : ℝ≥0∞) ∂μ := by
  convert_to lintegral μ (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ lintegral μ (thickenedIndicatorAux δ E)
  · rw [lintegral_indicator _ E_mble]
    

Proof state:
case h.e'_3
α : Type u_1
β : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
ι : Type u_5
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
⊢ ↑↑μ E = ∫⁻ (a : α) in E, 1 ∂μ

Next tactic:
simp only [lintegral_one, Measure.restrict_apply, MeasurableSet.univ, univ_inter]
theorem measure_le_lintegral_thickenedIndicatorAux (μ : Measure α) {E : Set α}
    (E_mble : MeasurableSet E) (δ : ℝ) : μ E ≤ ∫⁻ a, (thickenedIndicatorAux δ E a : ℝ≥0∞) ∂μ := by
  convert_to lintegral μ (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ lintegral μ (thickenedIndicatorAux δ E)
  · rw [lintegral_indicator _ E_mble]
    simp only [lintegral_one, Measure.restrict_apply, MeasurableSet.univ, univ_inter]
  · 

Proof state:
α : Type u_1
β : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
ι : Type u_5
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
⊢ lintegral μ (indicator E fun x => 1) ≤ lintegral μ (thickenedIndicatorAux δ E)

Next tactic:
apply lintegral_mono
theorem measure_le_lintegral_thickenedIndicatorAux (μ : Measure α) {E : Set α}
    (E_mble : MeasurableSet E) (δ : ℝ) : μ E ≤ ∫⁻ a, (thickenedIndicatorAux δ E a : ℝ≥0∞) ∂μ := by
  convert_to lintegral μ (E.indicator fun _ => (1 : ℝ≥0∞)) ≤ lintegral μ (thickenedIndicatorAux δ E)
  · rw [lintegral_indicator _ E_mble]
    simp only [lintegral_one, Measure.restrict_apply, MeasurableSet.univ, univ_inter]
  · apply lintegral_mono
    

Proof state:
case hfg
α : Type u_1
β : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
ι : Type u_5
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
⊢ (fun a => indicator E (fun x => 1) a) ≤ fun a => thickenedIndicatorAux δ E a

Next tactic:
apply indicator_le_thickenedIndicatorAux
theorem measure_le_lintegral_thickenedIndicator (μ : Measure α) {E : Set α}
    (E_mble : MeasurableSet E) {δ : ℝ} (δ_pos : 0 < δ) :
    μ E ≤ ∫⁻ a, (thickenedIndicator δ_pos E a : ℝ≥0∞) ∂μ := by
  

Proof state:
α : Type u_1
β : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
ι : Type u_5
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
δ_pos : 0 < δ
⊢ ↑↑μ E ≤ ∫⁻ (a : α), ↑((thickenedIndicator δ_pos E) a) ∂μ

Next tactic:
convert measure_le_lintegral_thickenedIndicatorAux μ E_mble δ
theorem measure_le_lintegral_thickenedIndicator (μ : Measure α) {E : Set α}
    (E_mble : MeasurableSet E) {δ : ℝ} (δ_pos : 0 < δ) :
    μ E ≤ ∫⁻ a, (thickenedIndicator δ_pos E a : ℝ≥0∞) ∂μ := by
  convert measure_le_lintegral_thickenedIndicatorAux μ E_mble δ
  

Proof state:
case h.e'_4.h.e'_4.h
α : Type u_1
β : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
ι : Type u_5
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
δ_pos : 0 < δ
x✝ : α
⊢ ↑((thickenedIndicator δ_pos E) x✝) = thickenedIndicatorAux δ E x✝

Next tactic:
dsimp
theorem measure_le_lintegral_thickenedIndicator (μ : Measure α) {E : Set α}
    (E_mble : MeasurableSet E) {δ : ℝ} (δ_pos : 0 < δ) :
    μ E ≤ ∫⁻ a, (thickenedIndicator δ_pos E a : ℝ≥0∞) ∂μ := by
  convert measure_le_lintegral_thickenedIndicatorAux μ E_mble δ
  dsimp
  

Proof state:
case h.e'_4.h.e'_4.h
α : Type u_1
β : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
ι : Type u_5
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
δ_pos : 0 < δ
x✝ : α
⊢ ↑(ENNReal.toNNReal (thickenedIndicatorAux δ E x✝)) = thickenedIndicatorAux δ E x✝

Next tactic:
simp only [thickenedIndicatorAux_lt_top.ne, ENNReal.coe_toNNReal, Ne.def, not_false_iff]
theorem Integrable.simpleFunc_mul (g : SimpleFunc β ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
g : SimpleFunc β ℝ
hf : Integrable f
⊢ Integrable (↑g * f)

Next tactic:
refine'
    SimpleFunc.induction (fun c s hs => _)
      (fun g₁ g₂ _ h_int₁ h_int₂ =>
        (h_int₁.add h_int₂).congr (by rw [SimpleFunc.coe_add, add_mul]))
      g
theorem Integrable.simpleFunc_mul (g : SimpleFunc β ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  refine'
    SimpleFunc.induction (fun c s hs => _)
      (fun g₁ g₂ _ h_int₁ h_int₂ =>
        (h_int₁.add h_int₂).congr (by 

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
g : SimpleFunc β ℝ
hf : Integrable f
g₁ g₂ : SimpleFunc β ℝ
x✝ : Disjoint (support ↑g₁) (support ↑g₂)
h_int₁ : Integrable (↑g₁ * f)
h_int₂ : Integrable (↑g₂ * f)
⊢ ↑g₁ * f + ↑g₂ * f =ᵐ[μ] ↑(g₁ + g₂) * f

Next tactic:
rw [SimpleFunc.coe_add, add_mul]
theorem Integrable.simpleFunc_mul (g : SimpleFunc β ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  refine'
    SimpleFunc.induction (fun c s hs => _)
      (fun g₁ g₂ _ h_int₁ h_int₂ =>
        (h_int₁.add h_int₂).congr (by rw [SimpleFunc.coe_add, add_mul]))
      g
  

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
g : SimpleFunc β ℝ
hf : Integrable f
c : ℝ
s : Set β
hs : MeasurableSet s
⊢ Integrable (↑(SimpleFunc.piecewise s hs (SimpleFunc.const β c) (SimpleFunc.const β 0)) * f)

Next tactic:
simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const,
    SimpleFunc.coe_zero, Set.piecewise_eq_indicator]
theorem Integrable.simpleFunc_mul (g : SimpleFunc β ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  refine'
    SimpleFunc.induction (fun c s hs => _)
      (fun g₁ g₂ _ h_int₁ h_int₂ =>
        (h_int₁.add h_int₂).congr (by rw [SimpleFunc.coe_add, add_mul]))
      g
  simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const,
    SimpleFunc.coe_zero, Set.piecewise_eq_indicator]
  

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
g : SimpleFunc β ℝ
hf : Integrable f
c : ℝ
s : Set β
hs : MeasurableSet s
⊢ Integrable (Set.indicator s (const β c) * f)

Next tactic:
have : Set.indicator s (Function.const β c) * f = s.indicator (c • f) := by
    ext1 x
    by_cases hx : x ∈ s
    · simp only [hx, Pi.mul_apply, Set.indicator_of_mem, Pi.smul_apply, Algebra.id.smul_eq_mul,
        ← Function.const_def]
    · simp only [hx, Pi.mul_apply, Set.indicator_of_not_mem, not_false_iff, zero_mul]
theorem Integrable.simpleFunc_mul (g : SimpleFunc β ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  refine'
    SimpleFunc.induction (fun c s hs => _)
      (fun g₁ g₂ _ h_int₁ h_int₂ =>
        (h_int₁.add h_int₂).congr (by rw [SimpleFunc.coe_add, add_mul]))
      g
  simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const,
    SimpleFunc.coe_zero, Set.piecewise_eq_indicator]
  have : Set.indicator s (Function.const β c) * f = s.indicator (c • f) := by
    

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
g : SimpleFunc β ℝ
hf : Integrable f
c : ℝ
s : Set β
hs : MeasurableSet s
⊢ Set.indicator s (const β c) * f = Set.indicator s (c • f)

Next tactic:
ext1 x
theorem Integrable.simpleFunc_mul (g : SimpleFunc β ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  refine'
    SimpleFunc.induction (fun c s hs => _)
      (fun g₁ g₂ _ h_int₁ h_int₂ =>
        (h_int₁.add h_int₂).congr (by rw [SimpleFunc.coe_add, add_mul]))
      g
  simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const,
    SimpleFunc.coe_zero, Set.piecewise_eq_indicator]
  have : Set.indicator s (Function.const β c) * f = s.indicator (c • f) := by
    ext1 x
    

Proof state:
case h
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
g : SimpleFunc β ℝ
hf : Integrable f
c : ℝ
s : Set β
hs : MeasurableSet s
x : β
⊢ (Set.indicator s (const β c) * f) x = Set.indicator s (c • f) x

Next tactic:
by_cases hx : x ∈ s
theorem Integrable.simpleFunc_mul (g : SimpleFunc β ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  refine'
    SimpleFunc.induction (fun c s hs => _)
      (fun g₁ g₂ _ h_int₁ h_int₂ =>
        (h_int₁.add h_int₂).congr (by rw [SimpleFunc.coe_add, add_mul]))
      g
  simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const,
    SimpleFunc.coe_zero, Set.piecewise_eq_indicator]
  have : Set.indicator s (Function.const β c) * f = s.indicator (c • f) := by
    ext1 x
    by_cases hx : x ∈ s
    · 

Proof state:
case pos
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
g : SimpleFunc β ℝ
hf : Integrable f
c : ℝ
s : Set β
hs : MeasurableSet s
x : β
hx : x ∈ s
⊢ (Set.indicator s (const β c) * f) x = Set.indicator s (c • f) x

Next tactic:
simp only [hx, Pi.mul_apply, Set.indicator_of_mem, Pi.smul_apply, Algebra.id.smul_eq_mul,
        ← Function.const_def]
theorem Integrable.simpleFunc_mul (g : SimpleFunc β ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  refine'
    SimpleFunc.induction (fun c s hs => _)
      (fun g₁ g₂ _ h_int₁ h_int₂ =>
        (h_int₁.add h_int₂).congr (by rw [SimpleFunc.coe_add, add_mul]))
      g
  simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const,
    SimpleFunc.coe_zero, Set.piecewise_eq_indicator]
  have : Set.indicator s (Function.const β c) * f = s.indicator (c • f) := by
    ext1 x
    by_cases hx : x ∈ s
    · simp only [hx, Pi.mul_apply, Set.indicator_of_mem, Pi.smul_apply, Algebra.id.smul_eq_mul,
        ← Function.const_def]
    · 

Proof state:
case neg
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
g : SimpleFunc β ℝ
hf : Integrable f
c : ℝ
s : Set β
hs : MeasurableSet s
x : β
hx : x ∉ s
⊢ (Set.indicator s (const β c) * f) x = Set.indicator s (c • f) x

Next tactic:
simp only [hx, Pi.mul_apply, Set.indicator_of_not_mem, not_false_iff, zero_mul]
theorem Integrable.simpleFunc_mul (g : SimpleFunc β ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  refine'
    SimpleFunc.induction (fun c s hs => _)
      (fun g₁ g₂ _ h_int₁ h_int₂ =>
        (h_int₁.add h_int₂).congr (by rw [SimpleFunc.coe_add, add_mul]))
      g
  simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const,
    SimpleFunc.coe_zero, Set.piecewise_eq_indicator]
  have : Set.indicator s (Function.const β c) * f = s.indicator (c • f) := by
    ext1 x
    by_cases hx : x ∈ s
    · simp only [hx, Pi.mul_apply, Set.indicator_of_mem, Pi.smul_apply, Algebra.id.smul_eq_mul,
        ← Function.const_def]
    · simp only [hx, Pi.mul_apply, Set.indicator_of_not_mem, not_false_iff, zero_mul]
  

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
g : SimpleFunc β ℝ
hf : Integrable f
c : ℝ
s : Set β
hs : MeasurableSet s
this : Set.indicator s (const β c) * f = Set.indicator s (c • f)
⊢ Integrable (Set.indicator s (const β c) * f)

Next tactic:
rw [this, integrable_indicator_iff hs]
theorem Integrable.simpleFunc_mul (g : SimpleFunc β ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  refine'
    SimpleFunc.induction (fun c s hs => _)
      (fun g₁ g₂ _ h_int₁ h_int₂ =>
        (h_int₁.add h_int₂).congr (by rw [SimpleFunc.coe_add, add_mul]))
      g
  simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const,
    SimpleFunc.coe_zero, Set.piecewise_eq_indicator]
  have : Set.indicator s (Function.const β c) * f = s.indicator (c • f) := by
    ext1 x
    by_cases hx : x ∈ s
    · simp only [hx, Pi.mul_apply, Set.indicator_of_mem, Pi.smul_apply, Algebra.id.smul_eq_mul,
        ← Function.const_def]
    · simp only [hx, Pi.mul_apply, Set.indicator_of_not_mem, not_false_iff, zero_mul]
  rw [this, integrable_indicator_iff hs]
  

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
g : SimpleFunc β ℝ
hf : Integrable f
c : ℝ
s : Set β
hs : MeasurableSet s
this : Set.indicator s (const β c) * f = Set.indicator s (c • f)
⊢ IntegrableOn (c • f) s

Next tactic:
exact (hf.smul c).integrableOn
theorem Integrable.simpleFunc_mul' (hm : m ≤ m0) (g : @SimpleFunc β m ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
hm : m ≤ m0
g : SimpleFunc β ℝ
hf : Integrable f
⊢ Integrable (↑g * f)

Next tactic:
rw [← SimpleFunc.coe_toLargerSpace_eq hm g]
theorem Integrable.simpleFunc_mul' (hm : m ≤ m0) (g : @SimpleFunc β m ℝ) (hf : Integrable f μ) :
    Integrable (⇑g * f) μ := by
  rw [← SimpleFunc.coe_toLargerSpace_eq hm g]; 

Proof state:
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : NormedAddCommGroup E
f : β → ℝ
m m0 : MeasurableSpace β
μ : Measure β
hm : m ≤ m0
g : SimpleFunc β ℝ
hf : Integrable f
⊢ Integrable (↑(SimpleFunc.toLargerSpace hm g) * f)

Next tactic:
exact hf.simpleFunc_mul (g.toLargerSpace hm)
/-- Consider a parameterized integral `a ↦ ∫ x, L (g x) (f a x)` where `L` is bilinear,
`g` is locally integrable and `f` is continuous and uniformly compactly supported. Then the
integral depends continuously on `a`. -/
lemma continuousOn_integral_bilinear_of_locally_integrable_of_compact_support
    [NormedSpace 𝕜 E] (L : F →L[𝕜] G →L[𝕜] E)
    {f : α → β → G} {s : Set α} {k : Set β} {g : β → F}
    (hk : IsCompact k) (hf : ContinuousOn f.uncurry (s ×ˢ univ))
    (hfs : ∀ p, ∀ x, p ∈ s → x ∉ k → f p x = 0) (hg : IntegrableOn g k μ) :
    ContinuousOn (fun a ↦ ∫ x, L (g x) (f a x) ∂μ) s := by
  

Proof state:
α✝ : Type u_1
β✝ : Type u_2
E : Type u_3
F✝ : Type u_4
inst✝¹² : MeasurableSpace α✝
ι : Type u_5
inst✝¹¹ : NormedAddCommGroup E
α : Type u_6
β : Type u_7
F : Type u_8
G : Type u_9
𝕜 : Type u_10
inst✝¹⁰ : TopologicalSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : OpensMeasurableSpace β
μ : Measure β
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : NormedSpace 𝕜 E
L : F →L[𝕜] G →L[𝕜] E
f : α → β → G
s : Set α
k : Set β
g : β → F
hk : IsCompact k
hf : ContinuousOn (uncurry f) (s ×ˢ univ)
hfs : ∀ (p : α) (x : β), p ∈ s → x ∉ k → f p x = 0
hg : IntegrableOn g k
⊢ ContinuousOn (fun a => ∫ (x : β), (L (g x)) (f a x) ∂μ) s

Next tactic:
have A : ∀ p ∈ s, Continuous (f p) := fun p hp ↦ by
    refine hf.comp_continuous (continuous_const.prod_mk continuous_id') fun x => ?_
    simpa only [prod_mk_mem_set_prod_eq, mem_univ, and_true] using hp
/-- Consider a parameterized integral `a ↦ ∫ x, L (g x) (f a x)` where `L` is bilinear,
`g` is locally integrable and `f` is continuous and uniformly compactly supported. Then the
integral depends continuously on `a`. -/
lemma continuousOn_integral_bilinear_of_locally_integrable_of_compact_support
    [NormedSpace 𝕜 E] (L : F →L[𝕜] G →L[𝕜] E)
    {f : α → β → G} {s : Set α} {k : Set β} {g : β → F}
    (hk : IsCompact k) (hf : ContinuousOn f.uncurry (s ×ˢ univ))
    (hfs : ∀ p, ∀ x, p ∈ s → x ∉ k → f p x = 0) (hg : IntegrableOn g k μ) :
    ContinuousOn (fun a ↦ ∫ x, L (g x) (f a x) ∂μ) s := by
  have A : ∀ p ∈ s, Continuous (f p) := fun p hp ↦ by
    

Proof state:
α✝ : Type u_1
β✝ : Type u_2
E : Type u_3
F✝ : Type u_4
inst✝¹² : MeasurableSpace α✝
ι : Type u_5
inst✝¹¹ : NormedAddCommGroup E
α : Type u_6
β : Type u_7
F : Type u_8
G : Type u_9
𝕜 : Type u_10
inst✝¹⁰ : TopologicalSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : OpensMeasurableSpace β
μ : Measure β
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : NormedSpace 𝕜 E
L : F →L[𝕜] G →L[𝕜] E
f : α → β → G
s : Set α
k : Set β
g : β → F
hk : IsCompact k
hf : ContinuousOn (uncurry f) (s ×ˢ univ)
hfs : ∀ (p : α) (x : β), p ∈ s → x ∉ k → f p x = 0
hg : IntegrableOn g k
p : α
hp : p ∈ s
⊢ Continuous (f p)

Next tactic:
refine hf.comp_continuous (continuous_const.prod_mk continuous_id') fun x => ?_
/-- Consider a parameterized integral `a ↦ ∫ x, L (g x) (f a x)` where `L` is bilinear,
`g` is locally integrable and `f` is continuous and uniformly compactly supported. Then the
integral depends continuously on `a`. -/
lemma continuousOn_integral_bilinear_of_locally_integrable_of_compact_support
    [NormedSpace 𝕜 E] (L : F →L[𝕜] G →L[𝕜] E)
    {f : α → β → G} {s : Set α} {k : Set β} {g : β → F}
    (hk : IsCompact k) (hf : ContinuousOn f.uncurry (s ×ˢ univ))
    (hfs : ∀ p, ∀ x, p ∈ s → x ∉ k → f p x = 0) (hg : IntegrableOn g k μ) :
    ContinuousOn (fun a ↦ ∫ x, L (g x) (f a x) ∂μ) s := by
  have A : ∀ p ∈ s, Continuous (f p) := fun p hp ↦ by
    refine hf.comp_continuous (continuous_const.prod_mk continuous_id') fun x => ?_
    

Proof state:
α✝ : Type u_1
β✝ : Type u_2
E : Type u_3
F✝ : Type u_4
inst✝¹² : MeasurableSpace α✝
ι : Type u_5
inst✝¹¹ : NormedAddCommGroup E
α : Type u_6
β : Type u_7
F : Type u_8
G : Type u_9
𝕜 : Type u_10
inst✝¹⁰ : TopologicalSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : OpensMeasurableSpace β
μ : Measure β
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : NormedSpace 𝕜 E
L : F →L[𝕜] G →L[𝕜] E
f : α → β → G
s : Set α
k : Set β
g : β → F
hk : IsCompact k
hf : ContinuousOn (uncurry f) (s ×ˢ univ)
hfs : ∀ (p : α) (x : β), p ∈ s → x ∉ k → f p x = 0
hg : IntegrableOn g k
p : α
hp : p ∈ s
x : β
⊢ (p, x) ∈ s ×ˢ univ

Next tactic:
simpa only [prod_mk_mem_set_prod_eq, mem_univ, and_true] using hp
/-- Consider a parameterized integral `a ↦ ∫ x, L (g x) (f a x)` where `L` is bilinear,
`g` is locally integrable and `f` is continuous and uniformly compactly supported. Then the
integral depends continuously on `a`. -/
lemma continuousOn_integral_bilinear_of_locally_integrable_of_compact_support
    [NormedSpace 𝕜 E] (L : F →L[𝕜] G →L[𝕜] E)
    {f : α → β → G} {s : Set α} {k : Set β} {g : β → F}
    (hk : IsCompact k) (hf : ContinuousOn f.uncurry (s ×ˢ univ))
    (hfs : ∀ p, ∀ x, p ∈ s → x ∉ k → f p x = 0) (hg : IntegrableOn g k μ) :
    ContinuousOn (fun a ↦ ∫ x, L (g x) (f a x) ∂μ) s := by
  have A : ∀ p ∈ s, Continuous (f p) := fun p hp ↦ by
    refine hf.comp_continuous (continuous_const.prod_mk continuous_id') fun x => ?_
    simpa only [prod_mk_mem_set_prod_eq, mem_univ, and_true] using hp
  

Proof state:
α✝ : Type u_1
β✝ : Type u_2
E : Type u_3
F✝ : Type u_4
inst✝¹² : MeasurableSpace α✝
ι : Type u_5
inst✝¹¹ : NormedAddCommGroup E
α : Type u_6
β : Type u_7
F : Type u_8
G : Type u_9
𝕜 : Type u_10
inst✝¹⁰ : TopologicalSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : OpensMeasurableSpace β
μ : Measure β
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : NormedSpace 𝕜 E
L : F →L[𝕜] G →L[𝕜] E
f : α → β → G
s : Set α
k : Set β
g : β → F
hk : IsCompact k
hf : ContinuousOn (uncurry f) (s ×ˢ univ)
hfs : ∀ (p : α) (x : β), p ∈ s → x ∉ k → f p x = 0
hg : IntegrableOn g k
A : ∀ p ∈ s, Continuous (f p)
⊢ ContinuousOn (fun a => ∫ (x : β), (L (g x)) (f a x) ∂μ) s

Next tactic:
intro q hq