File size: 8,909 Bytes
59d1c80 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 | import OAI.Geometry.IsometricImmersion.Energy.WeightPrimitiveParameter
import OAI.Geometry.IsometricImmersion.Energy.HyperbolicEnergyDensity
namespace OAI
noncomputable section
open Set Filter MeasureTheory
open scoped ContDiff Topology Interval
namespace SmoothLocal.Hyperbolic
open SmoothLocal.Geometry SmoothLocal.Weighted SmoothLocal.ODE
def movingIntervalIntegral (left right : ℝ → ℝ) (f : Coord → ℝ) (theta : ℝ) : ℝ :=
∫ xi in left theta..right theta, f (coordinatePoint xi theta)
def inwardLeft (x0 theta0 speed : ℝ) (theta : ℝ) : ℝ :=
x0 + speed * (theta - theta0)
def inwardRight (x0 theta0 speed : ℝ) (theta : ℝ) : ℝ :=
x0 - speed * (theta - theta0)
theorem inwardLeft_hasDerivAt (x0 theta0 speed theta : ℝ) :
HasDerivAt (inwardLeft x0 theta0 speed) speed theta := by
unfold inwardLeft
simpa only [inwardLeft, mul_one, id_eq] using
(((hasDerivAt_id theta).sub_const theta0).const_mul speed).const_add x0
theorem inwardRight_hasDerivAt (x0 theta0 speed theta : ℝ) :
HasDerivAt (inwardRight x0 theta0 speed) (-speed) theta := by
unfold inwardRight
simpa only [inwardRight, mul_one, zero_sub, id_eq, Pi.sub_def] using
(hasDerivAt_const theta x0).sub
(((hasDerivAt_id theta).sub_const theta0).const_mul speed)
theorem inward_interval_length (xl xr theta0 speed theta : ℝ) :
inwardRight xr theta0 speed theta - inwardLeft xl theta0 speed theta =
xr - xl - 2 * speed * (theta - theta0) := by
unfold inwardRight inwardLeft
ring
theorem movingPoint_hasDerivAt {x : ℝ → ℝ} {dx theta : ℝ}
(hx : HasDerivAt x dx theta) :
HasDerivAt (fun t => coordinatePoint (x t) t)
(dx • Pi.single 0 (1 : ℝ) + Pi.single 1 (1 : ℝ) : Coord) theta := by
simpa only [coordinatePoint, one_smul, id_eq, Pi.add_def] using
(hx.smul_const (Pi.single 0 (1 : ℝ) : Coord)).add
((hasDerivAt_id theta).smul_const (Pi.single 1 (1 : ℝ) : Coord))
theorem slice_intervalIntegrable
{f : Coord → ℝ} {radius lo hi xl xr theta : ℝ}
(hf : ContinuousOn f (coordinateRectangle radius lo hi))
(hxl : xl ∈ Ioo (-radius) radius) (hxr : xr ∈ Ioo (-radius) radius)
(htheta : theta ∈ Ioo lo hi) :
IntervalIntegrable (fun xi => f (coordinatePoint xi theta)) volume xl xr := by
have hc : ContinuousOn (fun xi => f (coordinatePoint xi theta)) (Ioo (-radius) radius) :=
hf.comp (by unfold coordinatePoint; fun_prop) (fun xi hxi => point_mem_rectangle hxi htheta)
exact (hc.mono (fun xi hxi =>
⟨lt_of_lt_of_le (lt_min hxl.1 hxr.1) hxi.1,
lt_of_le_of_lt hxi.2 (max_lt hxl.2 hxr.2)⟩)).intervalIntegrable
theorem movingIntervalIntegral_eq_primitive
{f : Coord → ℝ} {left right : ℝ → ℝ} {radius lo hi theta : ℝ}
(hf : ContinuousOn f (coordinateRectangle radius lo hi)) (hradius : 0 < radius)
(hl : left theta ∈ Ioo (-radius) radius) (hr : right theta ∈ Ioo (-radius) radius)
(htheta : theta ∈ Ioo lo hi) :
movingIntervalIntegral left right f theta =
coordinatePrimitive f (coordinatePoint (right theta) theta) -
coordinatePrimitive f (coordinatePoint (left theta) theta) := by
have h0 : (0 : ℝ) ∈ Ioo (-radius) radius := ⟨by linarith, hradius⟩
have hrI := slice_intervalIntegrable hf h0 hr htheta
have hlI := slice_intervalIntegrable hf h0 hl htheta
simpa [movingIntervalIntegral, coordinatePrimitive, coordinatePoint] using
(intervalIntegral.integral_interval_sub_left hrI hlI).symm
theorem movingPrimitive_hasDerivAt
{f : Coord → ℝ} {x : ℝ → ℝ} {radius lo hi theta dx : ℝ}
(hf : ContDiffOn ℝ ∞ f (coordinateRectangle radius lo hi)) (hradius : 0 < radius)
(hx : HasDerivAt x dx theta) (hxt : x theta ∈ Ioo (-radius) radius)
(htheta : theta ∈ Ioo lo hi) :
HasDerivAt (fun t => coordinatePrimitive f (coordinatePoint (x t) t))
(dx * f (coordinatePoint (x theta) theta) +
∫ xi in 0..x theta, coordPartial 1 f (coordinatePoint xi theta)) theta := by
have hp := point_mem_rectangle hxt htheta
have hd : DifferentiableAt ℝ (coordinatePrimitive f) (coordinatePoint (x theta) theta) :=
((coordinatePrimitive_contDiffOn hf).contDiffAt
((coordinateRectangle_isOpen radius lo hi).mem_nhds hp)).differentiableAt (by simp)
have hchain := HasFDerivAt.comp_hasDerivAt theta
(f := fun t => coordinatePoint (x t) t) hd.hasFDerivAt
(movingPoint_hasDerivAt (x := x) hx)
have ht := coordinatePrimitive_partial_t hf hradius hp
have hs := coordinatePrimitive_partial_s hf hradius hp
simp only [coordPartial] at ht hs
simp only [map_add, map_smul,
smul_eq_mul, ht, hs] at hchain
simpa [coordinatePoint, coordPartial, Function.comp_def] using hchain
theorem movingIntervalIntegral_hasDerivAt
{f : Coord → ℝ} {left right : ℝ → ℝ} {radius lo hi theta dl dr : ℝ}
(hf : ContDiffOn ℝ ∞ f (coordinateRectangle radius lo hi)) (hradius : 0 < radius)
(hl : HasDerivAt left dl theta) (hr : HasDerivAt right dr theta)
(hlt : left theta ∈ Ioo (-radius) radius)
(hrt : right theta ∈ Ioo (-radius) radius) (htheta : theta ∈ Ioo lo hi) :
HasDerivAt (movingIntervalIntegral left right f)
((∫ xi in left theta..right theta, coordPartial 1 f (coordinatePoint xi theta)) +
dr * f (coordinatePoint (right theta) theta) -
dl * f (coordinatePoint (left theta) theta)) theta := by
have hright := movingPrimitive_hasDerivAt hf hradius hr hrt htheta
have hleft := movingPrimitive_hasDerivAt hf hradius hl hlt htheta
have hdiff := hright.sub hleft
have h0 : (0 : ℝ) ∈ Ioo (-radius) radius := ⟨by linarith, hradius⟩
have hf1 := (partial_contDiffOn hf (coordinateRectangle_isOpen radius lo hi) 1).continuousOn
have hIsub := intervalIntegral.integral_interval_sub_left
(slice_intervalIntegrable hf1 h0 hrt htheta)
(slice_intervalIntegrable hf1 h0 hlt htheta)
have he :
(dr * f (coordinatePoint (right theta) theta) +
∫ xi in 0..right theta, coordPartial 1 f (coordinatePoint xi theta)) -
(dl * f (coordinatePoint (left theta) theta) +
∫ xi in 0..left theta, coordPartial 1 f (coordinatePoint xi theta)) =
(∫ xi in left theta..right theta, coordPartial 1 f (coordinatePoint xi theta)) +
dr * f (coordinatePoint (right theta) theta) -
dl * f (coordinatePoint (left theta) theta) := by linarith
rw [he] at hdiff
apply hdiff.congr_of_eventuallyEq
filter_upwards [hl.continuousAt.preimage_mem_nhds (isOpen_Ioo.mem_nhds hlt),
hr.continuousAt.preimage_mem_nhds (isOpen_Ioo.mem_nhds hrt),
isOpen_Ioo.mem_nhds htheta] with t hlt' hrt' ht'
exact movingIntervalIntegral_eq_primitive hf.continuousOn hradius hlt' hrt' ht'
theorem inwardIntervalIntegral_hasDerivAt
{f : Coord → ℝ} {radius lo hi xl xr theta0 speed theta : ℝ}
(hf : ContDiffOn ℝ ∞ f (coordinateRectangle radius lo hi)) (hradius : 0 < radius)
(hl : inwardLeft xl theta0 speed theta ∈ Ioo (-radius) radius)
(hr : inwardRight xr theta0 speed theta ∈ Ioo (-radius) radius)
(htheta : theta ∈ Ioo lo hi) :
HasDerivAt
(movingIntervalIntegral (inwardLeft xl theta0 speed) (inwardRight xr theta0 speed) f)
((∫ xi in inwardLeft xl theta0 speed theta..inwardRight xr theta0 speed theta,
coordPartial 1 f (coordinatePoint xi theta)) -
speed * (f (coordinatePoint (inwardRight xr theta0 speed theta) theta) +
f (coordinatePoint (inwardLeft xl theta0 speed theta) theta))) theta := by
convert movingIntervalIntegral_hasDerivAt hf hradius
(inwardLeft_hasDerivAt xl theta0 speed theta)
(inwardRight_hasDerivAt xr theta0 speed theta) hl hr htheta using 1
ring
theorem slice_integral_partial_xi
{f : Coord → ℝ} {radius lo hi xl xr theta : ℝ}
(hf : ContDiffOn ℝ ∞ f (coordinateRectangle radius lo hi))
(hxl : xl ∈ Ioo (-radius) radius) (hxr : xr ∈ Ioo (-radius) radius)
(htheta : theta ∈ Ioo lo hi) :
(∫ xi in xl..xr, coordPartial 0 f (coordinatePoint xi theta)) =
f (coordinatePoint xr theta) - f (coordinatePoint xl theta) := by
have hmem {xi : ℝ} (hxi : xi ∈ uIcc xl xr) :
coordinatePoint xi theta ∈ coordinateRectangle radius lo hi :=
point_mem_rectangle
⟨lt_of_lt_of_le (lt_min hxl.1 hxr.1) hxi.1,
lt_of_le_of_lt hxi.2 (max_lt hxl.2 hxr.2)⟩ htheta
apply intervalIntegral.integral_eq_sub_of_hasDerivAt
· intro xi hxi
have hd : DifferentiableAt ℝ f (coordinatePoint xi theta) :=
(hf.contDiffAt ((coordinateRectangle_isOpen radius lo hi).mem_nhds
(hmem hxi))).differentiableAt (by simp)
exact hd.hasFDerivAt.comp_hasDerivAt xi (point_hasDerivAt_t xi theta)
· exact slice_intervalIntegrable
(partial_contDiffOn hf (coordinateRectangle_isOpen radius lo hi) 0).continuousOn
hxl hxr htheta
end SmoothLocal.Hyperbolic
end
end OAI
|