| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open MeasureTheory Filter |
| open scoped Topology |
|
|
| namespace Problem358 |
|
|
| /-- Joint measurability is preserved by integrating between measurable endpoints. -/ |
| theorem stronglyMeasurable_intervalIntegral_endpoints |
| {X : Type*} [MeasurableSpace X] {f : X → ℝ → ℝ} {a b : X → ℝ} |
| (hf : Measurable (Function.uncurry f)) (ha : Measurable a) (hb : Measurable b) : |
| StronglyMeasurable (fun x => ∫ t in a x..b x, f x t) := by |
| let S : Set (X × ℝ) := {p | a p.1 < p.2 ∧ p.2 ≤ b p.1} |
| let T : Set (X × ℝ) := {p | b p.1 < p.2 ∧ p.2 ≤ a p.1} |
| have hS : MeasurableSet S := |
| (measurableSet_lt (ha.comp measurable_fst) measurable_snd).inter |
| (measurableSet_le measurable_snd (hb.comp measurable_fst)) |
| have hT : MeasurableSet T := |
| (measurableSet_lt (hb.comp measurable_fst) measurable_snd).inter |
| (measurableSet_le measurable_snd (ha.comp measurable_fst)) |
| have hleft : StronglyMeasurable (fun x => ∫ t : ℝ, |
| S.indicator (Function.uncurry f) (x, t)) := |
| StronglyMeasurable.integral_prod_right (f := fun x t => |
| S.indicator (Function.uncurry f) (x, t)) (by |
| convert (hf.indicator hS).stronglyMeasurable using 1 |
| funext p |
| rcases p with ⟨x, t⟩ |
| rfl) |
| have hright : StronglyMeasurable (fun x => ∫ t : ℝ, |
| T.indicator (Function.uncurry f) (x, t)) := |
| StronglyMeasurable.integral_prod_right (f := fun x t => |
| T.indicator (Function.uncurry f) (x, t)) (by |
| convert (hf.indicator hT).stronglyMeasurable using 1 |
| funext p |
| rcases p with ⟨x, t⟩ |
| rfl) |
| convert hleft.sub hright using 1 |
| ext x |
| change (∫ t in a x..b x, f x t) = |
| (∫ t, (Set.Ioc (a x) (b x)).indicator (f x) t) - |
| (∫ t, (Set.Ioc (b x) (a x)).indicator (f x) t) |
| rw [integral_indicator measurableSet_Ioc, integral_indicator measurableSet_Ioc] |
| rfl |
|
|
| /-- Differentiate a moving one-dimensional boundary, then integrate over the |
| transverse variables. Continuity is required only at the unperturbed boundary; |
| the integrand may be discontinuous away from that boundary. -/ |
| theorem hasDerivAt_integral_moving_boundary |
| {X : Type*} [MeasurableSpace X] {μ : Measure X} |
| {f : X → ℝ → ℝ} {b B : X → ℝ} |
| (hmeas : ∀ h : ℝ, AEStronglyMeasurable |
| (fun x => ∫ t in (0 : ℝ)..h * b x, f x t) μ) |
| (htrace : AEStronglyMeasurable (fun x => f x 0 * b x) μ) |
| (hslice : ∀ᵐ x ∂μ, StronglyMeasurableAtFilter (f x) (nhds 0)) |
| (hcont : ∀ᵐ x ∂μ, ContinuousAt (f x) 0) |
| (hbound : ∀ᵐ x ∂μ, ∀ t : ℝ, ‖f x t‖ ≤ B x) |
| (hdom : Integrable (fun x => |b x| * B x) μ) : |
| HasDerivAt (fun h : ℝ => ∫ x, (∫ t in (0 : ℝ)..h * b x, f x t) ∂μ) |
| (∫ x, f x 0 * b x ∂μ) 0 := by |
| let F : ℝ → X → ℝ := fun h x => ∫ t in (0 : ℝ)..h * b x, f x t |
| let D : X → ℝ →L[ℝ] ℝ := fun x => |
| (1 : ℝ →L[ℝ] ℝ).smulRight (f x 0 * b x) |
| have hDmeas : AEStronglyMeasurable D μ := |
| (ContinuousLinearMap.smulRightL ℝ ℝ ℝ 1).continuous.comp_aestronglyMeasurable htrace |
| have hdiff : ∀ᵐ x ∂μ, HasFDerivAt (fun h => F h x) (D x) 0 := by |
| filter_upwards [hslice, hcont] with x hx hc |
| have hf := intervalIntegral.integral_hasDerivAt_right |
| (IntervalIntegrable.refl (f := f x) (a := (0 : ℝ))) hx hc |
| have hmul := (hasDerivAt_id (0 : ℝ)).mul_const (b x) |
| have hf' : HasDerivAt (fun u => ∫ t in (0 : ℝ)..u, f x t) |
| (f x 0) ((fun h : ℝ => id h * b x) 0) := by |
| simpa using hf |
| have hd : HasDerivAt (fun h => F h x) (f x 0 * b x) 0 := by |
| simpa [F, Function.comp_def] using hf'.comp 0 hmul |
| exact hd.hasFDerivAt |
| have hbase : Integrable (F 0) μ := by |
| simp [F] |
| have hlip : ∀ᵐ x ∂μ, ∀ h ∈ (Set.univ : Set ℝ), |
| ‖F h x - F 0 x‖ ≤ (|b x| * B x) * ‖h - 0‖ := by |
| filter_upwards [hbound] with x hx |
| intro h _ |
| have hi := intervalIntegral.norm_integral_le_of_norm_le_const |
| (a := (0 : ℝ)) (b := h * b x) (fun t _ => hx t) |
| simpa [F, abs_mul, Real.norm_eq_abs, mul_assoc, mul_left_comm, mul_comm] using hi |
| obtain ⟨hDint, hD⟩ := hasFDerivAt_integral_of_dominated_loc_of_lip' |
| (F := F) (F' := D) (s := Set.univ) (x₀ := (0 : ℝ)) |
| (bound := fun x => |b x| * B x) Filter.univ_mem |
| (fun h _ => hmeas h) hbase hDmeas hlip hdom hdiff |
| have hd := hD.hasDerivAt |
| rw [ContinuousLinearMap.integral_apply hDint] at hd |
| simpa [D, F] using hd |
|
|
| /-- A moving-boundary derivative with all measurability discharged from a jointly |
| measurable integrand and a measurable boundary velocity. -/ |
| theorem hasDerivAt_integral_moving_boundary_of_measurable |
| {X : Type*} [MeasurableSpace X] {μ : Measure X} |
| {f : X → ℝ → ℝ} {b B : X → ℝ} |
| (hf : Measurable (Function.uncurry f)) (hb : Measurable b) |
| (hcont : ∀ᵐ x ∂μ, ContinuousAt (f x) 0) |
| (hbound : ∀ᵐ x ∂μ, ∀ t : ℝ, ‖f x t‖ ≤ B x) |
| (hdom : Integrable (fun x => |b x| * B x) μ) : |
| HasDerivAt (fun h : ℝ => ∫ x, (∫ t in (0 : ℝ)..h * b x, f x t) ∂μ) |
| (∫ x, f x 0 * b x ∂μ) 0 := by |
| apply hasDerivAt_integral_moving_boundary _ _ _ hcont hbound hdom |
| · intro h |
| exact (stronglyMeasurable_intervalIntegral_endpoints hf measurable_const |
| (measurable_const.mul hb)).aestronglyMeasurable |
| · exact ((hf.comp (measurable_id.prodMk measurable_const)).mul hb).aestronglyMeasurable |
| · exact Eventually.of_forall fun x => |
| (hf.comp (measurable_const.prodMk measurable_id)).stronglyMeasurable.stronglyMeasurableAtFilter |
|
|
| /-- A moving-boundary derivative remains valid for a changing integrand. The |
| scaled pointwise limit is exactly what remains after removing the principal |
| moving halfspace in a telescoping product of cell indicators. -/ |
| theorem hasDerivAt_integral_moving_boundary_varying |
| {X : Type*} [MeasurableSpace X] {μ : Measure X} |
| {f : ℝ → X → ℝ → ℝ} {b B : X → ℝ} {trace : X → ℝ} |
| (hf : ∀ h, Measurable (Function.uncurry (f h))) (hb : Measurable b) |
| (hlim : ∀ᵐ x ∂μ, ∀ u : ℝ, |
| Tendsto (fun h : ℝ => f h x (h * u)) (nhds 0) (nhds (trace x))) |
| (hbound : ∀ᵐ x ∂μ, ∀ h t : ℝ, ‖f h x t‖ ≤ B x) |
| (hdom : Integrable (fun x => |b x| * B x) μ) : |
| HasDerivAt (fun h : ℝ => ∫ x, (∫ t in (0 : ℝ)..h * b x, f h x t) ∂μ) |
| (∫ x, b x * trace x ∂μ) 0 := by |
| let G : ℝ → X → ℝ := fun h x => ∫ u in (0 : ℝ)..b x, f h x (h * u) |
| have hGmeas : ∀ h, StronglyMeasurable (G h) := by |
| intro h |
| apply stronglyMeasurable_intervalIntegral_endpoints _ measurable_const hb |
| exact (hf h).comp (measurable_fst.prodMk (measurable_const.mul measurable_snd)) |
| have hGbound : ∀ h, ∀ᵐ x ∂μ, ‖G h x‖ ≤ |b x| * B x := by |
| intro h |
| filter_upwards [hbound] with x hx |
| have hi := intervalIntegral.norm_integral_le_of_norm_le_const |
| (a := (0 : ℝ)) (b := b x) (fun u _ => hx h (h * u)) |
| simpa [G, mul_comm] using hi |
| have hGlim : ∀ᵐ x ∂μ, Tendsto (fun h => G h x) (nhds 0) |
| (nhds (b x * trace x)) := by |
| filter_upwards [hlim, hbound] with x hx hxbound |
| have hi := intervalIntegral.tendsto_integral_filter_of_dominated_convergence |
| (a := (0 : ℝ)) (b := b x) (μ := volume) (l := nhds (0 : ℝ)) |
| (F := fun h u => f h x (h * u)) (f := fun _ => trace x) |
| (fun _ => B x) |
| (Eventually.of_forall fun h => |
| ((hf h).comp (measurable_const.prodMk |
| (measurable_const.mul measurable_id))).aestronglyMeasurable) |
| (Eventually.of_forall fun h => Eventually.of_forall fun u _ => hxbound h (h * u)) |
| intervalIntegrable_const |
| (Eventually.of_forall fun u _ => hx u) |
| simpa [G] using hi |
| have hHlim : Tendsto (fun h => ∫ x, G h x ∂μ) (nhds 0) |
| (nhds (∫ x, b x * trace x ∂μ)) := |
| tendsto_integral_filter_of_dominated_convergence (fun x => |b x| * B x) |
| (Eventually.of_forall fun h => (hGmeas h).aestronglyMeasurable) |
| (Eventually.of_forall hGbound) hdom hGlim |
| have hscale : ∀ h : ℝ, |
| (∫ x, (∫ t in (0 : ℝ)..h * b x, f h x t) ∂μ) = |
| h * ∫ x, G h x ∂μ := by |
| intro h |
| rw [← integral_const_mul] |
| apply integral_congr_ae |
| exact Eventually.of_forall fun x => by |
| simpa only [G, smul_eq_mul, mul_zero] using |
| (intervalIntegral.smul_integral_comp_mul_left (f h x) (a := (0 : ℝ)) |
| (b := b x) h).symm |
| rw [hasDerivAt_iff_tendsto_slope_zero] |
| apply (hHlim.mono_left nhdsWithin_le_nhds).congr' |
| filter_upwards [self_mem_nhdsWithin] with h hh |
| have hh0 : h ≠ 0 := by simpa using hh |
| simp [hscale, hh0, smul_eq_mul] |
| |
| /-- A varying boundary velocity is allowed as well. In moving-plane coordinates, |
| this covers the denominator introduced when the normal direction is perturbed. -/ |
| theorem hasDerivAt_integral_moving_boundary_varying_speed |
| {X : Type*} [MeasurableSpace X] {μ : Measure X} |
| {f : ℝ → X → ℝ → ℝ} {speed : ℝ → X → ℝ} {A B slope trace : X → ℝ} |
| (hf : ∀ h, Measurable (Function.uncurry (f h))) |
| (hspeed : ∀ h, Measurable (speed h)) |
| (hspeedlim : ∀ᵐ x ∂μ, Tendsto (fun h => speed h x) (nhds 0) (nhds (slope x))) |
| (hlim : ∀ᵐ x ∂μ, ∀ u : ℝ, |
| Tendsto (fun h : ℝ => f h x (h * speed h x * u)) (nhds 0) (nhds (trace x))) |
| (hspeedbound : ∀ᵐ x ∂μ, ∀ h : ℝ, |speed h x| ≤ A x) |
| (hbound : ∀ᵐ x ∂μ, ∀ h t : ℝ, ‖f h x t‖ ≤ B x) |
| (hdom : Integrable (fun x => A x * B x) μ) : |
| HasDerivAt (fun h : ℝ => ∫ x, (∫ t in (0 : ℝ)..h * speed h x, f h x t) ∂μ) |
| (∫ x, slope x * trace x ∂μ) 0 := by |
| let G : ℝ → X → ℝ → ℝ := fun h x t => speed h x * f h x (speed h x * t) |
| have hGmeas : ∀ h, Measurable (Function.uncurry (G h)) := by |
| intro h |
| exact ((hspeed h).comp measurable_fst).mul |
| ((hf h).comp (measurable_fst.prodMk |
| (((hspeed h).comp measurable_fst).mul measurable_snd))) |
| have hGlim : ∀ᵐ x ∂μ, ∀ u : ℝ, |
| Tendsto (fun h : ℝ => G h x (h * u)) (nhds 0) |
| (nhds (slope x * trace x)) := by |
| filter_upwards [hspeedlim, hlim] with x hx hy |
| intro u |
| simpa [G, mul_assoc, mul_comm, mul_left_comm] using hx.mul (hy u) |
| have hGbound : ∀ᵐ x ∂μ, ∀ h t : ℝ, ‖G h x t‖ ≤ A x * B x := by |
| filter_upwards [hspeedbound, hbound] with x hx hy |
| intro h t |
| have hB : 0 ≤ B x := (norm_nonneg _).trans (hy 0 0) |
| calc |
| ‖G h x t‖ = |speed h x| * ‖f h x (speed h x * t)‖ := by |
| simp [G, norm_mul, Real.norm_eq_abs] |
| _ ≤ A x * B x := mul_le_mul (hx h) (hy h (speed h x * t)) |
| (norm_nonneg _) ((abs_nonneg _).trans (hx h)) |
| have hg := hasDerivAt_integral_moving_boundary_varying |
| (f := G) (b := fun _ => (1 : ℝ)) (B := fun x => A x * B x) |
| hGmeas measurable_const hGlim hGbound (by simpa using hdom) |
| simp only [mul_one, one_mul] at hg |
| convert hg using 1 |
| funext h |
| apply integral_congr_ae |
| exact Eventually.of_forall fun x => by |
| change (∫ t in (0 : ℝ)..h * speed h x, f h x t) = |
| (∫ t in (0 : ℝ)..h, G h x t) |
| rw [show (∫ t in (0 : ℝ)..h, G h x t) = |
| speed h x * ∫ t in (0 : ℝ)..h, f h x (speed h x * t) by |
| exact intervalIntegral.integral_const_mul _ _] |
| simpa only [smul_eq_mul, mul_zero, mul_comm] using |
| (intervalIntegral.smul_integral_comp_mul_left (f h x) |
| (a := (0 : ℝ)) (b := h) (speed h x)).symm |
| |
| end Problem358 |
| |
| namespace Problem358 |
| |
| /-- The signed change of a threshold halfline is exactly its boundary strip. -/ |
| theorem integral_threshold_difference (f : ℝ → ℝ) (c : ℝ) : |
| (∫ t : ℝ, f t * ((if c ≤ t then (1 : ℝ) else 0) - |
| (if 0 ≤ t then (1 : ℝ) else 0))) = ∫ t in c..0, f t := by |
| classical |
| by_cases hc : c ≤ 0 |
| · have hid : (fun t : ℝ => f t * ((if c ≤ t then (1 : ℝ) else 0) - |
| (if 0 ≤ t then (1 : ℝ) else 0))) = (Set.Ico c 0).indicator f := by |
| funext t |
| simp only [Set.indicator, Set.mem_Ico] |
| split_ifs <;> simp_all <;> linarith |
| rw [hid, integral_indicator measurableSet_Ico, integral_Ico_eq_integral_Ioc, |
| intervalIntegral.integral_of_le hc] |
| · have hc' : 0 ≤ c := le_of_lt (lt_of_not_ge hc) |
| have hid : (fun t : ℝ => f t * ((if c ≤ t then (1 : ℝ) else 0) - |
| (if 0 ≤ t then (1 : ℝ) else 0))) = |
| fun t => -((Set.Ico 0 c).indicator f t) := by |
| funext t |
| simp only [Set.indicator, Set.mem_Ico] |
| split_ifs <;> simp_all <;> linarith |
| rw [hid, integral_neg, integral_indicator measurableSet_Ico, |
| integral_Ico_eq_integral_Ioc, intervalIntegral.integral_of_ge hc'] |
| |
| /-- The derivative of one varying halfspace factor, with all other varying |
| factors included in `f`. This is stated as an iterated integral so that an |
| orthogonal-coordinate/Fubini argument can apply it directly. -/ |
| theorem hasDerivAt_integral_halfspace_difference |
| {X : Type*} [MeasurableSpace X] {μ : Measure X} |
| {f : ℝ → X → ℝ → ℝ} {speed : ℝ → X → ℝ} {A B slope trace : X → ℝ} |
| (hf : ∀ h, Measurable (Function.uncurry (f h))) |
| (hspeed : ∀ h, Measurable (speed h)) |
| (hspeedlim : ∀ᵐ x ∂μ, Tendsto (fun h => speed h x) (nhds 0) (nhds (slope x))) |
| (hlim : ∀ᵐ x ∂μ, ∀ u : ℝ, |
| Tendsto (fun h : ℝ => f h x (-(h * speed h x * u))) (nhds 0) (nhds (trace x))) |
| (hspeedbound : ∀ᵐ x ∂μ, ∀ h : ℝ, |speed h x| ≤ A x) |
| (hbound : ∀ᵐ x ∂μ, ∀ h t : ℝ, ‖f h x t‖ ≤ B x) |
| (hdom : Integrable (fun x => A x * B x) μ) : |
| HasDerivAt (fun h : ℝ => ∫ x, (∫ t : ℝ, |
| f h x t * ((if -(h * speed h x) ≤ t then (1 : ℝ) else 0) - |
| (if 0 ≤ t then (1 : ℝ) else 0))) ∂μ) |
| (∫ x, slope x * trace x ∂μ) 0 := by |
| have hg := hasDerivAt_integral_moving_boundary_varying_speed |
| (f := fun h x t => f h x (-t)) (speed := speed) |
| (A := A) (B := B) (slope := slope) (trace := trace) |
| (fun h => (hf h).comp (measurable_fst.prodMk measurable_snd.neg)) |
| hspeed hspeedlim hlim hspeedbound |
| (hbound.mono fun x hx h t => hx h (-t)) hdom |
| convert hg using 1 |
| funext h |
| apply integral_congr_ae |
| exact Eventually.of_forall fun x => by |
| dsimp only |
| rw [integral_threshold_difference, intervalIntegral.integral_comp_neg] |
| simp |
| |
| /-- Local-in-parameter version of the halfspace derivative. In particular, |
| velocity denominators need only stay away from zero near the base configuration. -/ |
| theorem hasDerivAt_integral_halfspace_difference_local |
| {X : Type*} [MeasurableSpace X] {μ : Measure X} |
| {f : ℝ → X → ℝ → ℝ} {speed : ℝ → X → ℝ} {A B slope trace : X → ℝ} |
| {s : Set ℝ} (hs : s ∈ nhds 0) |
| (hf : ∀ h, Measurable (Function.uncurry (f h))) |
| (hspeed : ∀ h, Measurable (speed h)) |
| (hspeedlim : ∀ᵐ x ∂μ, Tendsto (fun h => speed h x) (nhds 0) (nhds (slope x))) |
| (hlim : ∀ᵐ x ∂μ, ∀ u : ℝ, |
| Tendsto (fun h : ℝ => f h x (-(h * speed h x * u))) (nhds 0) (nhds (trace x))) |
| (hspeedbound : ∀ᵐ x ∂μ, ∀ h ∈ s, |speed h x| ≤ A x) |
| (hbound : ∀ᵐ x ∂μ, ∀ h ∈ s, ∀ t : ℝ, ‖f h x t‖ ≤ B x) |
| (hdom : Integrable (fun x => A x * B x) μ) : |
| HasDerivAt (fun h : ℝ => ∫ x, (∫ t : ℝ, |
| f h x t * ((if -(h * speed h x) ≤ t then (1 : ℝ) else 0) - |
| (if 0 ≤ t then (1 : ℝ) else 0))) ∂μ) |
| (∫ x, slope x * trace x ∂μ) 0 := by |
| classical |
| let ff : ℝ → X → ℝ → ℝ := fun h x t => if h ∈ s then f h x t else 0 |
| let vv : ℝ → X → ℝ := fun h x => if h ∈ s then speed h x else 0 |
| have hzero : (0 : ℝ) ∈ s := mem_of_mem_nhds hs |
| have hff : ∀ h, Measurable (Function.uncurry (ff h)) := by |
| intro h |
| by_cases hh : h ∈ s |
| · simpa [ff, hh, Function.uncurry] using hf h |
| · convert (measurable_const : Measurable (fun _ : X × ℝ => (0 : ℝ))) using 1 |
| funext p |
| rcases p with ⟨x, t⟩ |
| simp [ff, hh] |
| have hvv : ∀ h, Measurable (vv h) := by |
| intro h |
| by_cases hh : h ∈ s |
| · simpa [vv, hh] using hspeed h |
| · simp [vv, hh] |
| have hvlim : ∀ᵐ x ∂μ, Tendsto (fun h => vv h x) (nhds 0) (nhds (slope x)) := by |
| filter_upwards [hspeedlim] with x hx |
| apply hx.congr' |
| filter_upwards [hs] with h hh |
| simp [vv, hh] |
| have hflim : ∀ᵐ x ∂μ, ∀ u : ℝ, |
| Tendsto (fun h : ℝ => ff h x (-(h * vv h x * u))) (nhds 0) (nhds (trace x)) := by |
| filter_upwards [hlim] with x hx |
| intro u |
| apply (hx u).congr' |
| filter_upwards [hs] with h hh |
| simp [ff, vv, hh] |
| have hvbound : ∀ᵐ x ∂μ, ∀ h : ℝ, |vv h x| ≤ A x := by |
| filter_upwards [hspeedbound] with x hx |
| have hA : 0 ≤ A x := (abs_nonneg _).trans (hx 0 hzero) |
| intro h |
| by_cases hh : h ∈ s |
| · simpa [vv, hh] using hx h hh |
| · simpa [vv, hh] using hA |
| have hfbound : ∀ᵐ x ∂μ, ∀ h t : ℝ, ‖ff h x t‖ ≤ B x := by |
| filter_upwards [hbound] with x hx |
| have hB : 0 ≤ B x := (norm_nonneg _).trans (hx 0 hzero 0) |
| intro h t |
| by_cases hh : h ∈ s |
| · simpa [ff, hh] using hx h hh t |
| · simpa [ff, hh] using hB |
| have hd := hasDerivAt_integral_halfspace_difference hff hvv hvlim hflim hvbound hfbound hdom |
| apply hd.congr_of_eventuallyEq |
| filter_upwards [hs] with h hh |
| simp [ff, vv, hh] |
| |
| /-- Multiplication by the signed difference of two threshold indicators |
| preserves ambient integrability. -/ |
| theorem integrable_threshold_difference |
| {X : Type*} [MeasurableSpace X] {μ : Measure X} |
| {f : X × ℝ → ℝ} {c : X → ℝ} |
| (hf : Integrable f (μ.prod volume)) (hc : Measurable c) : |
| Integrable (fun p : X × ℝ => f p * |
| ((if c p.1 ≤ p.2 then (1 : ℝ) else 0) - |
| (if 0 ≤ p.2 then (1 : ℝ) else 0))) (μ.prod volume) := by |
| have hfirst : Measurable (fun p : X × ℝ => |
| if c p.1 ≤ p.2 then (1 : ℝ) else 0) := |
| Measurable.ite (measurableSet_le (hc.comp measurable_fst) measurable_snd) |
| measurable_const measurable_const |
| have hsecond : Measurable (fun p : X × ℝ => |
| if 0 ≤ p.2 then (1 : ℝ) else 0) := |
| Measurable.ite (measurableSet_le measurable_const measurable_snd) |
| measurable_const measurable_const |
| apply hf.norm.mono' (hf.aestronglyMeasurable.mul |
| (hfirst.sub hsecond).aestronglyMeasurable) |
| exact Eventually.of_forall fun p => by |
| have hcut : ‖(if c p.1 ≤ p.2 then (1 : ℝ) else 0) - |
| (if 0 ≤ p.2 then (1 : ℝ) else 0)‖ ≤ 1 := by |
| split_ifs <;> norm_num |
| simp only [Pi.mul_apply, Pi.sub_apply] |
| rw [norm_mul] |
| exact (mul_le_mul_of_nonneg_left hcut (norm_nonneg _)).trans_eq (mul_one _) |
|
|
| /-- Product-measure version of the local moving-face derivative. Ambient |
| integrability is enough to discharge the Fubini step, while slice domination |
| controls the derivative independently of the parameter. -/ |
| theorem hasDerivAt_prod_integral_halfspace_difference_local |
| {X : Type*} [MeasurableSpace X] {μ : Measure X} [SFinite μ] |
| {f : ℝ → X → ℝ → ℝ} {speed : ℝ → X → ℝ} {A B slope trace : X → ℝ} |
| {s : Set ℝ} (hs : s ∈ nhds 0) |
| (hf : ∀ h, Measurable (Function.uncurry (f h))) |
| (hspeed : ∀ h, Measurable (speed h)) |
| (hspeedlim : ∀ᵐ x ∂μ, Tendsto (fun h => speed h x) (nhds 0) (nhds (slope x))) |
| (hlim : ∀ᵐ x ∂μ, ∀ u : ℝ, |
| Tendsto (fun h : ℝ => f h x (-(h * speed h x * u))) (nhds 0) (nhds (trace x))) |
| (hspeedbound : ∀ᵐ x ∂μ, ∀ h ∈ s, |speed h x| ≤ A x) |
| (hbound : ∀ᵐ x ∂μ, ∀ h ∈ s, ∀ t : ℝ, ‖f h x t‖ ≤ B x) |
| (hdom : Integrable (fun x => A x * B x) μ) |
| (hInt : ∀ᶠ h in nhds 0, Integrable (Function.uncurry (f h)) (μ.prod volume)) : |
| HasDerivAt (fun h : ℝ => ∫ p : X × ℝ, |
| f h p.1 p.2 * ((if -(h * speed h p.1) ≤ p.2 then (1 : ℝ) else 0) - |
| (if 0 ≤ p.2 then (1 : ℝ) else 0)) ∂μ.prod volume) |
| (∫ x, slope x * trace x ∂μ) 0 := by |
| have hd := hasDerivAt_integral_halfspace_difference_local hs hf hspeed |
| hspeedlim hlim hspeedbound hbound hdom |
| apply hd.congr_of_eventuallyEq |
| filter_upwards [hInt] with h hh |
| exact integral_prod _ (integrable_threshold_difference hh |
| (measurable_const.mul (hspeed h)).neg) |
|
|
| end Problem358 |
|
|
| end |
|
|
| end OAI |
|
|
