File size: 2,246 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Flow.FlowSmooth

namespace OAI

/-! Smooth dependence on the initial phase for a nonautonomous equation,
obtained by adjoining phase as an autonomous coordinate. -/

noncomputable section
namespace ForcedComputation.Flow
open scoped ContDiff NNReal

variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [FiniteDimensional ℝ E] [CompleteSpace E]

theorem transition_contDiff (V : C(ℝ Γ— E, E))
    (hV : ContDiff ℝ ∞ (V : ℝ Γ— E β†’ E)) {L : ℝβ‰₯0}
    (hL : LipschitzWith L V) {Ξ© : ℝ β†’ ℝ β†’ E β†’ E}
    (hode : βˆ€ a t x, HasDerivAt (fun s => Ξ© a s x) (V (a + t, Ξ© a t x)) t)
    (hzero : βˆ€ a x, Ξ© a 0 x = x) :
    ContDiff ℝ ∞ (fun p : ℝ Γ— (ℝ Γ— E) => Ξ© p.1 p.2.1 p.2.2) := by
  let Z : C(ℝ Γ— E, ℝ Γ— E) :=
    ⟨fun p => (1, V p), continuous_const.prodMk V.continuous⟩
  have hZ : ContDiff ℝ ∞ (Z : ℝ Γ— E β†’ ℝ Γ— E) := contDiff_const.prodMk hV
  have hZL : LipschitzWith L Z := by
    change LipschitzWith L (fun p : ℝ Γ— E => ((1 : ℝ), V p))
    simpa only [max_eq_right (show (0 : ℝβ‰₯0) ≀ L from bot_le)] using
      (LipschitzWith.const (1 : ℝ)).prodMk hL
  let Ξ¨ : ℝ β†’ (ℝ Γ— E) β†’ ℝ Γ— E := fun t p => (p.1 + t, Ξ© p.1 t p.2)
  have hΞ¨ (t : ℝ) (p : ℝ Γ— E) :
      HasDerivAt (fun s => Ξ¨ s p) (Z (Ξ¨ t p)) t :=
    ((hasDerivAt_id t).const_add p.1).prodMk (hode p.1 t p.2)
  have hi (p : ℝ Γ— E) : Ξ¨ 0 p = p := by simp only [Ξ¨, add_zero, hzero]
  have hs := flow_contDiff Z hZ hZL hΨ hi
  have hq : ContDiff ℝ ∞ (fun p : ℝ Γ— (ℝ Γ— E) => (p.2.1, (p.1, p.2.2))) :=
    contDiff_snd.fst.prodMk (contDiff_fst.prodMk contDiff_snd.snd)
  exact hs.snd.comp hq

theorem transition_backward_contDiff (V : C(ℝ Γ— E, E))
    (hV : ContDiff ℝ ∞ (V : ℝ Γ— E β†’ E)) {L : ℝβ‰₯0}
    (hL : LipschitzWith L V) {Ξ© : ℝ β†’ ℝ β†’ E β†’ E}
    (hode : βˆ€ a t x, HasDerivAt (fun s => Ξ© a s x) (V (a + t, Ξ© a t x)) t)
    (hzero : βˆ€ a x, Ξ© a 0 x = x) :
    ContDiff ℝ ∞ (fun p : ℝ Γ— E => Ξ© p.1 (-p.1) p.2) :=
  (transition_contDiff V hV hL hode hzero).comp
    (contDiff_fst.prodMk (contDiff_fst.neg.prodMk contDiff_snd))

end ForcedComputation.Flow

end

end OAI