| import OAI.Geometry.IsometricImmersion.Energy.WeightPrimitive |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Set Filter MeasureTheory |
| open scoped ContDiff Topology Interval |
|
|
| namespace SmoothLocal.Flow |
| open SmoothLocal.ODE |
|
|
| def pairRectangle (R a b : ℝ) : Set (ℝ × ℝ) := Ioo (-R) R ×ˢ Ioo a b |
|
|
| def pairPrimitive (B : ℝ × ℝ → ℝ) (p : ℝ × ℝ) : ℝ := |
| ∫ t in 0..p.1, B (t, p.2) |
|
|
| def pairPartialY (B : ℝ × ℝ → ℝ) (p : ℝ × ℝ) : ℝ := |
| fderiv ℝ B p (0, 1) |
|
|
| def pairCompactFamily (B : ℝ × ℝ → ℝ) (r : ℝ) (y : ℝ) : IntervalFunctions r := |
| ContinuousMap.mkD (fun x : Icc (-r) r => B (x, y)) 0 |
|
|
| theorem pairRectangle_isOpen (R a b : ℝ) : IsOpen (pairRectangle R a b) := |
| isOpen_Ioo.prod isOpen_Ioo |
|
|
| theorem exists_compact_time_interval {R x : ℝ} (hx : x ∈ Ioo (-R) R) : |
| ∃ r : ℝ, 0 < r ∧ r < R ∧ x ∈ Ioo (-r) r := by |
| have hxa : |x| < R := abs_lt.mpr hx |
| refine ⟨(|x| + R) / 2, ?_, ?_, ?_⟩ |
| · nlinarith [abs_nonneg x] |
| · linarith |
| · apply abs_lt.mp |
| linarith |
|
|
| theorem pairCompactFamily_joint_continuous {B : ℝ × ℝ → ℝ} {R a b r : ℝ} |
| (hB : ContinuousOn B (pairRectangle R a b)) (hrR : r < R) : |
| ContinuousOn (fun p : ℝ × Icc (-r) r => B (p.2, p.1)) |
| (Ioo a b ×ˢ (univ : Set (Icc (-r) r))) := by |
| exact hB.comp (by fun_prop) |
| (fun p hp => ⟨⟨(neg_lt_neg hrR).trans_le p.2.2.1, |
| p.2.2.2.trans_lt hrR⟩, hp.1⟩) |
|
|
| theorem pairCompactFamily_continuousOn {B : ℝ × ℝ → ℝ} {R a b r : ℝ} |
| (hB : ContinuousOn B (pairRectangle R a b)) (hrR : r < R) : |
| ContinuousOn (pairCompactFamily B r) (Ioo a b) := |
| ContinuousMap.continuousOn_mkD_of_uncurry _ 0 (pairCompactFamily_joint_continuous hB hrR) |
|
|
| theorem pairCompactFamily_apply {B : ℝ × ℝ → ℝ} {R a b r y : ℝ} |
| (hB : ContinuousOn B (pairRectangle R a b)) (hrR : r < R) |
| (hy : y ∈ Ioo a b) (x : Icc (-r) r) : pairCompactFamily B r y x = B (x, y) := by |
| have hc : Continuous (fun t : Icc (-r) r => B (t, y)) := |
| (pairCompactFamily_joint_continuous hB hrR).comp_continuous |
| (continuous_const.prodMk continuous_id) (fun _ => ⟨hy, mem_univ _⟩) |
| unfold pairCompactFamily |
| rw [ContinuousMap.mkD_of_continuous hc] |
| rfl |
|
|
| theorem pairPrimitive_eq_clamped {B : ℝ × ℝ → ℝ} {R a b r x y : ℝ} |
| (hB : ContinuousOn B (pairRectangle R a b)) (hr : 0 < r) (hrR : r < R) |
| (hx : x ∈ Ioo (-r) r) (hy : y ∈ Ioo a b) : |
| pairPrimitive B (x, y) = |
| intervalExtension r hr (primitiveCLM r hr (pairCompactFamily B r y)) x := by |
| rw [intervalExtension_apply_of_mem r hr _ ⟨hx.1.le, hx.2.le⟩, primitiveCLM_apply] |
| unfold pairPrimitive |
| apply intervalIntegral.integral_congr |
| intro t ht |
| have ht' : t ∈ Icc (-r) r := |
| uIcc_subset_Icc ⟨by linarith, hr.le⟩ ⟨hx.1.le, hx.2.le⟩ ht |
| rw [intervalExtension_apply_of_mem r hr _ ht', pairCompactFamily_apply hB hrR hy] |
|
|
| theorem pairPrimitive_continuousOn {B : ℝ × ℝ → ℝ} {R a b : ℝ} |
| (hB : ContinuousOn B (pairRectangle R a b)) : |
| ContinuousOn (pairPrimitive B) (pairRectangle R a b) := by |
| intro p hp |
| obtain ⟨r, hr, hrR, hpr⟩ := exists_compact_time_interval hp.1 |
| have hF := (primitiveCLM r hr).continuous.comp_continuousOn |
| (pairCompactFamily_continuousOn hB hrR) |
| have hc := intervalExtension_family_continuousOn r hr hF |
| have hn : (univ : Set ℝ) ×ˢ Ioo a b ∈ 𝓝 p := |
| (isOpen_univ.prod isOpen_Ioo).mem_nhds ⟨mem_univ _, hp.2⟩ |
| have he : pairPrimitive B =ᶠ[𝓝 p] |
| (fun q => intervalExtension r hr (primitiveCLM r hr (pairCompactFamily B r q.2)) q.1) := by |
| filter_upwards [(pairRectangle_isOpen r a b).mem_nhds ⟨hpr, hp.2⟩] with q hq |
| exact pairPrimitive_eq_clamped hB hr hrR hq.1 hq.2 |
| exact ((hc.continuousAt hn).congr_of_eventuallyEq he).continuousWithinAt |
|
|
| theorem pairPartialY_contDiffOn {B : ℝ × ℝ → ℝ} {R a b : ℝ} (n : ℕ) |
| (hB : ContDiffOn ℝ (n + 1 : ℕ) B (pairRectangle R a b)) : |
| ContDiffOn ℝ n (pairPartialY B) (pairRectangle R a b) := by |
| have hd : ContDiffOn ℝ n (fderiv ℝ B) (pairRectangle R a b) := |
| hB.fderiv_of_isOpen (pairRectangle_isOpen R a b) (by simp) |
| exact hd.clm_apply contDiffOn_const |
|
|
| theorem pairCompactFamily_hasDerivAt {B : ℝ × ℝ → ℝ} {R a b r y : ℝ} |
| (hB : ContDiffOn ℝ 1 B (pairRectangle R a b)) (hrR : r < R) (hy : y ∈ Ioo a b) : |
| HasDerivAt (pairCompactFamily B r) (pairCompactFamily (pairPartialY B) r y) y := by |
| have hP : ContinuousOn (pairPartialY B) (pairRectangle R a b) := |
| (pairPartialY_contDiffOn 0 hB).continuousOn |
| apply hasDerivAt_continuousMap_of_eval (pairCompactFamily_continuousOn hP hrR) _ hy |
| intro u hu x |
| have hx : (x : ℝ) ∈ Ioo (-R) R := |
| ⟨(neg_lt_neg hrR).trans_le x.2.1, x.2.2.trans_lt hrR⟩ |
| have hxu : ((x : ℝ), u) ∈ pairRectangle R a b := ⟨hx, hu⟩ |
| have hd := ((hB.contDiffAt ((pairRectangle_isOpen R a b).mem_nhds hxu)).differentiableAt |
| (by norm_num)).hasFDerivAt |
| have hs : HasDerivAt (fun v : ℝ => ((x : ℝ), v)) (0, 1) u := |
| (hasDerivAt_const u (x : ℝ)).prodMk (hasDerivAt_id u) |
| have hpoint : HasDerivAt (fun v => B (x, v)) (pairPartialY B (x, u)) u := |
| hd.comp_hasDerivAt u hs |
| rw [pairCompactFamily_apply hP hrR hu x] |
| apply hpoint.congr_of_eventuallyEq |
| filter_upwards [isOpen_Ioo.mem_nhds hu] with v hv |
| exact pairCompactFamily_apply hB.continuousOn hrR hv x |
|
|
| theorem pairPrimitive_hasDerivAt_y {B : ℝ × ℝ → ℝ} {R a b x y : ℝ} |
| (hB : ContDiffOn ℝ 1 B (pairRectangle R a b)) |
| (hx : x ∈ Ioo (-R) R) (hy : y ∈ Ioo a b) : |
| HasDerivAt (fun v => pairPrimitive B (x, v)) (pairPrimitive (pairPartialY B) (x, y)) y := by |
| obtain ⟨r, hr, hrR, hxr⟩ := exists_compact_time_interval hx |
| have hP : ContinuousOn (pairPartialY B) (pairRectangle R a b) := |
| (pairPartialY_contDiffOn 0 hB).continuousOn |
| have hFB := pairCompactFamily_hasDerivAt hB hrR hy |
| have hPB := (primitiveCLM r hr).hasFDerivAt.comp_hasDerivAt y hFB |
| have hd := intervalExtension_family_hasDerivAt r hr hPB x |
| rw [← pairPrimitive_eq_clamped hP hr hrR hxr hy] at hd |
| apply hd.congr_of_eventuallyEq |
| filter_upwards [isOpen_Ioo.mem_nhds hy] with v hv |
| exact pairPrimitive_eq_clamped hB.continuousOn hr hrR hxr hv |
|
|
| theorem pairPrimitive_hasDerivAt_x {B : ℝ × ℝ → ℝ} {R a b x y : ℝ} |
| (hB : ContinuousOn B (pairRectangle R a b)) |
| (hx : x ∈ Ioo (-R) R) (hy : y ∈ Ioo a b) : |
| HasDerivAt (fun t => pairPrimitive B (t, y)) (B (x, y)) x := by |
| obtain ⟨r, hr, hrR, hxr⟩ := exists_compact_time_interval hx |
| have hd := intervalExtension_primitive_hasDerivAt r hr (pairCompactFamily B r y) hxr |
| rw [intervalExtension_apply_of_mem r hr _ ⟨hxr.1.le, hxr.2.le⟩, |
| pairCompactFamily_apply hB hrR hy] at hd |
| apply hd.congr_of_eventuallyEq |
| filter_upwards [isOpen_Ioo.mem_nhds hxr] with t ht |
| exact pairPrimitive_eq_clamped hB hr hrR ht hy |
|
|
| theorem pairPrimitive_contDiffOn_nat (n : ℕ) {B : ℝ × ℝ → ℝ} {R a b : ℝ} |
| (hB : ContDiffOn ℝ n B (pairRectangle R a b)) : |
| ContDiffOn ℝ n (pairPrimitive B) (pairRectangle R a b) := by |
| induction n generalizing B with |
| | zero => |
| simpa only [Nat.cast_zero, contDiffOn_zero] using pairPrimitive_continuousOn hB.continuousOn |
| | succ n hn => |
| have hB1 : ContDiffOn ℝ 1 B (pairRectangle R a b) := hB.of_le (by simp) |
| apply contDiffOn_succ_of_continuous_partials (pairRectangle_isOpen R a b) n |
| (hB.of_le (by simp)) (hn (pairPartialY_contDiffOn n hB)) |
| · intro p hp |
| exact pairPrimitive_hasDerivAt_x hB.continuousOn hp.1 hp.2 |
| · intro p hp |
| exact pairPrimitive_hasDerivAt_y hB1 hp.1 hp.2 |
|
|
| end SmoothLocal.Flow |
|
|
| end |
|
|
| end OAI |
|
|
