File size: 5,795 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
import OAI.Geometry.IsometricImmersion.Flows.FlowBounds
import Mathlib.Analysis.Calculus.InverseFunctionTheorem.ContDiff

namespace OAI

noncomputable section
open Set Filter MeasureTheory Function
open scoped ContDiff Topology Interval

namespace SmoothLocal.Flow
open SmoothLocal.Geometry SmoothLocal.ODE SmoothLocal.Weighted

def triangularLinearEquiv (a b : ℝ) (hb : b ≠ 0) : (ℝ × ℝ) ≃L[ℝ] (ℝ × ℝ) where
  toFun v := (v.1, a * v.1 + b * v.2)
  invFun w := (w.1, (w.2 - a * w.1) / b)
  left_inv v := by
    apply Prod.ext
    · rfl
    · dsimp
      field_simp [hb]
      ring
  right_inv w := by
    apply Prod.ext
    · rfl
    · dsimp
      field_simp [hb]
      ring
  map_add' v w := by
    apply Prod.ext <;> simp only [Prod.fst_add, Prod.snd_add]
    ring
  map_smul' c v := by
    apply Prod.ext <;> simp only [Prod.smul_fst, Prod.smul_snd, smul_eq_mul, RingHom.id_apply]
    ring
  continuous_toFun := by fun_prop
  continuous_invFun := by fun_prop

variable {q : Coord → ℝ} {U : Set Coord} {Y : ℝ → ℝ → ℝ}

theorem triangularFlow_hasFDerivAt_equiv
    (hq : ContDiffOn ℝ ∞ q U) (hU : IsOpen U) (hSU : modelSquare ⊆ U)
    (hY : ContinuousOn (uncurry Y) (Icc (-2 : ℝ) 2 ×ˢ Icc (-2 : ℝ) 2))
    (hrange : ∀ s ∈ Icc (-2 : ℝ) 2, ∀ t ∈ Icc (-2 : ℝ) 2,
      Y s t ∈ Icc (-3 : ℝ) 3)
    (hstart : ∀ s ∈ Icc (-2 : ℝ) 2, Y s 0 = s)
    (hode : ∀ s ∈ Icc (-2 : ℝ) 2, ∀ t ∈ Icc (-2 : ℝ) 2,
      HasDerivWithinAt (Y s) (-q (coordinatePoint t (Y s t))) (Icc (-2 : ℝ) 2) t)
    {p : ℝ × ℝ} (hp : p ∈ pairRectangle 2 (-2) 2) :
    ∃ A : (ℝ × ℝ) ≃L[ℝ] (ℝ × ℝ), HasFDerivAt (triangularFlow Y) (A : (ℝ × ℝ) →L[ℝ] (ℝ × ℝ)) p := by
  let F (v : ℝ × ℝ) := Y v.2 v.1
  let a := -q (coordinatePoint p.1 (Y p.2 p.1))
  let b := Real.exp (-(∫ r in 0..p.1, coordPartial 1 q (coordinatePoint r (Y p.2 r))))
  have hF : ContDiffOn ℝ ∞ F (pairRectangle 2 (-2) 2) :=
    cap_flow_joint_contDiffOn hq hU hSU hY hrange hstart hode
  have hd := ((hF.contDiffAt ((pairRectangle_isOpen 2 (-2) 2).mem_nhds hp)).differentiableAt
    (by simp)).hasFDerivAt
  have hdx : HasDerivAt (fun t => F (t, p.2)) a p.1 :=
    (hode p.2 ⟨hp.2.1.le, hp.2.2.le⟩ p.1 ⟨hp.1.1.le, hp.1.2.le⟩).hasDerivAt
      (Icc_mem_nhds hp.1.1 hp.1.2)
  have hdy : HasDerivAt (fun s => F (p.1, s)) b p.2 :=
    cap_flow_hasDerivAt_initial hq hU hSU hY hrange hstart hode hp.2 hp.1
  have hdx' : HasDerivAt (fun t => F (t, p.2)) (fderiv ℝ F p (1, 0)) p.1 := by
    convert hd.comp_hasDerivAt p.1 ((hasDerivAt_id p.1).prodMk
      (hasDerivAt_const p.1 p.2)) using 1
    rfl
  have hdy' : HasDerivAt (fun s => F (p.1, s)) (fderiv ℝ F p (0, 1)) p.2 := by
    convert hd.comp_hasDerivAt p.2 ((hasDerivAt_const p.2 p.1).prodMk
      (hasDerivAt_id p.2)) using 1
    rfl
  have hx : fderiv ℝ F p (1, 0) = a := hdx'.unique hdx
  have hy : fderiv ℝ F p (0, 1) = b := hdy'.unique hdy
  have hdeq : fderiv ℝ F p = jointDifferential a b := by
    apply ContinuousLinearMap.ext
    intro v
    have hv : v = v.1 • ((1, 0) : ℝ × ℝ) + v.2 • ((0, 1) : ℝ × ℝ) := by
      ext <;> simp
    calc
      fderiv ℝ F p v = v.1 * a + v.2 * b := by
        conv_lhs => rw [hv]
        simp only [map_add, map_smul, smul_eq_mul, hx, hy]
      _ = jointDifferential a b v := by simp [jointDifferential]
  have hFD : HasFDerivAt F (jointDifferential a b) p := hd.congr_fderiv hdeq
  have hb : b ≠ 0 := (Real.exp_pos _).ne'
  refine ⟨triangularLinearEquiv a b hb, ?_⟩
  have hTF := (hasFDerivAt_fst (𝕜 := ℝ) (p := p)).prodMk hFD
  convert hTF using 1 <;> first
    | rfl
    | (ext <;> simp [triangularLinearEquiv, jointDifferential])

theorem exists_triangularFlow_smooth_chart
    (hq : ContDiffOn ℝ ∞ q U) (hU : IsOpen U) (hSU : modelSquare ⊆ U)
    (hY : ContinuousOn (uncurry Y) (Icc (-2 : ℝ) 2 ×ˢ Icc (-2 : ℝ) 2))
    (hrange : ∀ s ∈ Icc (-2 : ℝ) 2, ∀ t ∈ Icc (-2 : ℝ) 2,
      Y s t ∈ Icc (-3 : ℝ) 3)
    (hstart : ∀ s ∈ Icc (-2 : ℝ) 2, Y s 0 = s)
    (hode : ∀ s ∈ Icc (-2 : ℝ) 2, ∀ t ∈ Icc (-2 : ℝ) 2,
      HasDerivWithinAt (Y s) (-q (coordinatePoint t (Y s t))) (Icc (-2 : ℝ) 2) t)
    {p : ℝ × ℝ} (hp : p ∈ pairRectangle 2 (-2) 2) :
    ∃ e : OpenPartialHomeomorph (ℝ × ℝ) (ℝ × ℝ),
      p ∈ e.source ∧ e.source ⊆ pairRectangle 2 (-2) 2 ∧
      (e : (ℝ × ℝ) → (ℝ × ℝ)) = triangularFlow Y ∧
      ContDiffOn ℝ ∞ e e.source ∧ ContDiffOn ℝ ∞ e.symm e.target := by
  let D := pairRectangle 2 (-2) 2
  have hD : IsOpen D := pairRectangle_isOpen 2 (-2) 2
  have hTF : ContDiffOn ℝ ∞ (triangularFlow Y) D :=
    contDiffOn_fst.prodMk (cap_flow_joint_contDiffOn hq hU hSU hY hrange hstart hode)
  have hTFp := hTF.contDiffAt (hD.mem_nhds hp)
  obtain ⟨A, hA⟩ := triangularFlow_hasFDerivAt_equiv hq hU hSU hY hrange hstart hode hp
  let e0 := hTFp.toOpenPartialHomeomorph (triangularFlow Y) hA (by simp)
  let e := e0.restrOpen D hD
  have heq : (e : (ℝ × ℝ) → (ℝ × ℝ)) = triangularFlow Y := rfl
  have hsub : e.source ⊆ D := fun _ hx => hx.2
  refine ⟨e, ⟨hTFp.mem_toOpenPartialHomeomorph_source hA (by simp), hp⟩,
    hsub, heq, ?_, ?_⟩
  · rw [heq]
    exact hTF.mono hsub
  · intro y hy
    have hx : e.symm y ∈ D := hsub (e.map_target hy)
    obtain ⟨L, hL⟩ := triangularFlow_hasFDerivAt_equiv hq hU hSU hY hrange hstart hode hx
    have hLe : HasFDerivAt e (L : (ℝ × ℝ) →L[ℝ] (ℝ × ℝ)) (e.symm y) := by
      rw [heq]
      exact hL
    have hfe : ContDiffAt ℝ ∞ e (e.symm y) := by
      rw [heq]
      exact hTF.contDiffAt (hD.mem_nhds hx)
    exact (e.contDiffAt_symm hy hLe hfe).contDiffWithinAt

end SmoothLocal.Flow

end

end OAI