l3lab/ntp-mathlib huggingface dataset:
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · 

Proof state:
case this
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
⊢ ∀ᵐ (t : G) ∂Measure.restrict μ s, ‖(L (f t)) (g (x₀ - t))‖ ≤ indicator s (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g ↑i‖) t

Next tactic:
refine' eventually_of_forall _
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · refine' eventually_of_forall _
    

Proof state:
case this
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
⊢ ∀ (x : G), ‖(L (f x)) (g (x₀ - x))‖ ≤ indicator s (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g ↑i‖) x

Next tactic:
refine' le_indicator (fun t ht => _) fun t ht => _
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · refine' eventually_of_forall _
    refine' le_indicator (fun t ht => _) fun t ht => _
    · 

Proof state:
case this.refine'_1
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
t : G
ht : t ∈ s
⊢ ‖(L (f t)) (g (x₀ - t))‖ ≤ ‖L‖ * ‖f t‖ * ⨆ i, ‖g ↑i‖

Next tactic:
apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · refine' eventually_of_forall _
    refine' le_indicator (fun t ht => _) fun t ht => _
    · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
      

Proof state:
case this.refine'_1.hy
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
t : G
ht : t ∈ s
⊢ ‖g (x₀ - t)‖ ≤ ⨆ i, ‖g ↑i‖

Next tactic:
refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · refine' eventually_of_forall _
    refine' le_indicator (fun t ht => _) fun t ht => _
    · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
      refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
      

Proof state:
case this.refine'_1.hy
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
t : G
ht : t ∈ s
⊢ -(x₀ - t) + x₀ ∈ s

Next tactic:
rwa [neg_sub, sub_add_cancel]
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · refine' eventually_of_forall _
    refine' le_indicator (fun t ht => _) fun t ht => _
    · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
      refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
      rwa [neg_sub, sub_add_cancel]
    · 

Proof state:
case this.refine'_2
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
t : G
ht : t ∉ s
⊢ ‖(L (f t)) (g (x₀ - t))‖ ≤ 0

Next tactic:
have : t ∉ support fun t => L (f t) (g (x₀ - t)) := mt (fun h => h2s h) ht
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · refine' eventually_of_forall _
    refine' le_indicator (fun t ht => _) fun t ht => _
    · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
      refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
      rwa [neg_sub, sub_add_cancel]
    · have : t ∉ support fun t => L (f t) (g (x₀ - t)) := mt (fun h => h2s h) ht
      

Proof state:
case this.refine'_2
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
t : G
ht : t ∉ s
this : t ∉ support fun t => (L (f t)) (g (x₀ - t))
⊢ ‖(L (f t)) (g (x₀ - t))‖ ≤ 0

Next tactic:
rw [nmem_support.mp this, norm_zero]
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · refine' eventually_of_forall _
    refine' le_indicator (fun t ht => _) fun t ht => _
    · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
      refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
      rwa [neg_sub, sub_add_cancel]
    · have : t ∉ support fun t => L (f t) (g (x₀ - t)) := mt (fun h => h2s h) ht
      rw [nmem_support.mp this, norm_zero]
  

Proof state:
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
this : ∀ᵐ (t : G) ∂Measure.restrict μ s, ‖(L (f t)) (g (x₀ - t))‖ ≤ indicator s (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g ↑i‖) t
⊢ IntegrableOn (fun t => (L (f t)) (g (x₀ - t))) s

Next tactic:
refine' Integrable.mono' _ _ this
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · refine' eventually_of_forall _
    refine' le_indicator (fun t ht => _) fun t ht => _
    · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
      refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
      rwa [neg_sub, sub_add_cancel]
    · have : t ∉ support fun t => L (f t) (g (x₀ - t)) := mt (fun h => h2s h) ht
      rw [nmem_support.mp this, norm_zero]
  refine' Integrable.mono' _ _ this
  · 

Proof state:
case refine'_1
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
this : ∀ᵐ (t : G) ∂Measure.restrict μ s, ‖(L (f t)) (g (x₀ - t))‖ ≤ indicator s (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g ↑i‖) t
⊢ Integrable fun a => indicator s (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g ↑i‖) a

Next tactic:
rw [integrable_indicator_iff hs]
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · refine' eventually_of_forall _
    refine' le_indicator (fun t ht => _) fun t ht => _
    · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
      refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
      rwa [neg_sub, sub_add_cancel]
    · have : t ∉ support fun t => L (f t) (g (x₀ - t)) := mt (fun h => h2s h) ht
      rw [nmem_support.mp this, norm_zero]
  refine' Integrable.mono' _ _ this
  · rw [integrable_indicator_iff hs]; 

Proof state:
case refine'_1
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
this : ∀ᵐ (t : G) ∂Measure.restrict μ s, ‖(L (f t)) (g (x₀ - t))‖ ≤ indicator s (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g ↑i‖) t
⊢ IntegrableOn (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g ↑i‖) s

Next tactic:
exact ((hf.norm.const_mul _).mul_const _).integrableOn
/-- A sufficient condition to prove that `f ⋆[L, μ] g` exists.
We assume that `f` is integrable on a set `s` and `g` is bounded and ae strongly measurable
on `x₀ - s` (note that both properties hold if `g` is continuous with compact support). -/
theorem BddAbove.convolutionExistsAt' {x₀ : G} {s : Set G}
    (hbg : BddAbove ((fun i => ‖g i‖) '' ((fun t => -t + x₀) ⁻¹' s))) (hs : MeasurableSet s)
    (h2s : (support fun t => L (f t) (g (x₀ - t))) ⊆ s) (hf : IntegrableOn f s μ)
    (hmg : AEStronglyMeasurable g <| map (fun t => x₀ - t) (μ.restrict s)) :
    ConvolutionExistsAt f g x₀ L μ := by
  -- porting note: can't `rw [ConvolutionExistsAt]`
  unfold ConvolutionExistsAt
  rw [← integrableOn_iff_integrable_of_support_subset h2s]
  set s' := (fun t => -t + x₀) ⁻¹' s
  have : ∀ᵐ t : G ∂μ.restrict s,
      ‖L (f t) (g (x₀ - t))‖ ≤ s.indicator (fun t => ‖L‖ * ‖f t‖ * ⨆ i : s', ‖g i‖) t
  · refine' eventually_of_forall _
    refine' le_indicator (fun t ht => _) fun t ht => _
    · apply_rules [L.le_of_op_norm₂_le_of_le, le_rfl]
      refine' (le_ciSup_set hbg <| mem_preimage.mpr _)
      rwa [neg_sub, sub_add_cancel]
    · have : t ∉ support fun t => L (f t) (g (x₀ - t)) := mt (fun h => h2s h) ht
      rw [nmem_support.mp this, norm_zero]
  refine' Integrable.mono' _ _ this
  · rw [integrable_indicator_iff hs]; exact ((hf.norm.const_mul _).mul_const _).integrableOn
  · 

Proof state:
case refine'_2
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedAddCommGroup E''
inst✝⁹ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedSpace 𝕜 E'
inst✝⁵ : NormedSpace 𝕜 E''
inst✝⁴ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝³ : MeasurableSpace G
μ ν : Measure G
inst✝² : AddGroup G
inst✝¹ : MeasurableAdd G
inst✝ : MeasurableNeg G
x₀ : G
s : Set G
hs : MeasurableSet s
h2s : (support fun t => (L (f t)) (g (x₀ - t))) ⊆ s
hf : IntegrableOn f s
hmg : AEStronglyMeasurable g (Measure.map (fun t => x₀ - t) (Measure.restrict μ s))
s' : Set G := (fun t => -t + x₀) ⁻¹' s
hbg : BddAbove ((fun i => ‖g i‖) '' s')
this : ∀ᵐ (t : G) ∂Measure.restrict μ s, ‖(L (f t)) (g (x₀ - t))‖ ≤ indicator s (fun t => ‖L‖ * ‖f t‖ * ⨆ i, ‖g ↑i‖) t
⊢ AEStronglyMeasurable (fun t => (L (f t)) (g (x₀ - t))) (Measure.restrict μ s)

Next tactic:
exact hf.aestronglyMeasurable.convolution_integrand_snd' L hmg