File size: 7,194 Bytes
caec230
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
import OAI.MathematicalPhysics.RapidForcing.FieldExpressions

namespace OAI


open scoped BigOperators Topology
open Set Filter
namespace RapidForcing

def EqBefore {E : Type} (R : ℝ) (v w : Field E) : Prop :=
  ∀ t, 0 ≤ t → t < R → ∀ x, v t x = w t x

namespace EqBefore
variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {R : ℝ} {v w : Field E}
lemma spatial (h : EqBefore R v w) (i : Fin 3) : EqBefore R (spatialD i v) (spatialD i w) := by
  intro t ht hR x
  have he : v t = w t := funext (h t ht hR)
  simp only [spatialD, he]
lemma time (h : EqBefore R v w) : EqBefore R (timeD v) (timeD w) := by
  intro t ht hR x
  apply Filter.EventuallyEq.derivWithin_eq_of_mem _ ht
  filter_upwards [self_mem_nhdsWithin, nhdsWithin_le_nhds (Iio_mem_nhds hR)] with s hs hsR
  exact h s hs hsR x
lemma mixed (h : EqBefore R v w) (l : ℕ) (α : MultiIndex) :
    EqBefore R (mixedD l α v) (mixedD l α w) := by
  have hsp (i : Fin 3) (n : ℕ) {a b : Field E} (hab : EqBefore R a b) :
      EqBefore R ((spatialD i)^[n] a) ((spatialD i)^[n] b) := by
    induction n with
    | zero => exact hab
    | succ n ih => simpa only [Function.iterate_succ_apply'] using ih.spatial i
  unfold mixedD spatialMulti
  induction l with
  | zero => exact hsp 0 _ (hsp 1 _ (hsp 2 _ h))
  | succ l ih => simpa only [Function.iterate_succ_apply'] using ih.time
end EqBefore

namespace EffectiveProfile
namespace Formula

noncomputable def pack (ν t : ℝ) (x : Space) : Fin 5 → ℝ := ![t, x 0, x 1, x 2, ν]
def spaceIndex (i : Fin 3) : Fin 5 := ⟨i.val + 1, by omega⟩

noncomputable def scalarField (a : Formula 5) (ν : ℝ) : Field ℝ :=
  fun t x => a.value (pack ν t x)
noncomputable def vectorField (a : Fin 3 → Formula 5) (ν : ℝ) : Field Space :=
  fun t x => WithLp.toLp 2 (fun i => (a i).scalarField ν t x)

lemma pack_smooth (ν : ℝ) : ContDiff ℝ (⊤ : ℕ∞) (fun p : ℝ × Space => pack ν p.1 p.2) := by
  apply contDiff_pi.mpr
  intro i
  fin_cases i <;> dsimp [pack] <;> fun_prop
lemma scalarField_smooth (a : Formula 5) (ν : ℝ) :
    ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (a.scalarField ν)) :=
  a.contDiff.comp (pack_smooth ν)
lemma vectorField_smooth (a : Fin 3 → Formula 5) (ν : ℝ) :
    ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (vectorField a ν)) := by
  apply (contDiff_piLp 2).mpr
  intro i
  exact (a i).scalarField_smooth ν

lemma pack_space_line (ν t : ℝ) (x : Space) (i : Fin 3) (s : ℝ) :
    pack ν t (x + s • basis i) = pack ν t x + s • Pi.single (spaceIndex i) 1 := by
  ext j
  fin_cases i <;> fin_cases j <;> simp [pack, basis, spaceIndex]
lemma pack_time_line (ν t : ℝ) (x : Space) (s : ℝ) :
    pack ν (t + s) x = pack ν t x + s • Pi.single (0 : Fin 5) 1 := by
  ext j
  fin_cases j <;> simp [pack]

lemma spatial_scalarField (a : Formula 5) (ν : ℝ) (i : Fin 3) :
    spatialD i (a.scalarField ν) = (a.diff (spaceIndex i)).scalarField ν := by
  funext t x
  have hline : HasDerivAt (fun s : ℝ => x + s • basis i) (basis i) 0 := by
    simpa using ((hasDerivAt_id (0 : ℝ)).smul_const (basis i)).const_add x
  have hd : DifferentiableAt ℝ (a.scalarField ν t) x :=
    ((a.scalarField_smooth ν).comp (contDiff_const.prodMk contDiff_id)).differentiable (by simp) x
  have hp := a.hasDerivAt_line (spaceIndex i) (pack ν t x) 0
  have he : (fun s : ℝ => a.value (pack ν t x + s • Pi.single (spaceIndex i) (1 : ℝ))) =
      fun s => a.scalarField ν t (x + s • basis i) := by
    funext s
    rw [← pack_space_line]
    rfl
  rw [he] at hp
  have hd' : HasFDerivAt (a.scalarField ν t) (fderiv ℝ (a.scalarField ν t) x)
      (x + (0 : ℝ) • basis i) := by simpa using hd.hasFDerivAt
  have hc := hd'.comp_hasDerivAt 0 hline
  simpa only [zero_smul, add_zero, spatialD, scalarField] using hc.unique hp

lemma time_scalarField (a : Formula 5) (ν : ℝ) (t : ℝ) (ht : 0 ≤ t) (x : Space) :
    timeD (a.scalarField ν) t x = (a.diff 0).scalarField ν t x := by
  have h := a.hasDerivAt_line 0 (pack ν 0 x) t
  have he : (fun s => a.value (pack ν 0 x + s • Pi.single 0 1)) =
      fun s => a.scalarField ν s x := by
    funext s
    rw [← pack_time_line, zero_add]
    rfl
  rw [he, ← pack_time_line, zero_add] at h
  exact h.hasDerivWithinAt.derivWithin (uniqueDiffOn_Ici 0 t ht)

lemma spatial_vectorField (a : Fin 3 → Formula 5) (ν : ℝ) (i : Fin 3) :
    spatialD i (vectorField a ν) = vectorField (fun j => (a j).diff (spaceIndex i)) ν := by
  funext t x
  ext j
  have hd : DifferentiableAt ℝ (vectorField a ν t) x :=
    ((vectorField_smooth a ν).comp (contDiff_const.prodMk contDiff_id)).differentiable (by simp) x
  change (fderiv ℝ (vectorField a ν t) x (basis i)) j = _
  rw [← fderiv_coordinate hd]
  exact congrFun (congrFun (spatial_scalarField (a j) ν i) t) x

lemma time_vectorField (a : Fin 3 → Formula 5) (ν : ℝ) (t : ℝ) (ht : 0 ≤ t) (x : Space) :
    timeD (vectorField a ν) t x = vectorField (fun j => (a j).diff 0) ν t x := by
  have hd : HasDerivAt (fun s => vectorField a ν s x)
      (vectorField (fun j => (a j).diff 0) ν t x) t := by
    apply (PiLp.continuousLinearEquiv 2 ℝ (fun _ : Fin 3 => ℝ)).symm.toContinuousLinearMap.hasFDerivAt.comp_hasDerivAt t
    apply hasDerivAt_pi.mpr
    intro j
    have h := (a j).hasDerivAt_line 0 (pack ν 0 x) t
    have he : (fun s => (a j).value (pack ν 0 x + s • Pi.single 0 1)) =
        fun s => (a j).scalarField ν s x := by
      funext s
      rw [← pack_time_line, zero_add]
      rfl
    rw [he, ← pack_time_line, zero_add] at h
    exact h
  exact hd.hasDerivWithinAt.derivWithin (uniqueDiffOn_Ici 0 t ht)

def mixed (l : ℕ) (α : MultiIndex) (a : Formula 5) : Formula 5 :=
  (diff 0)^[l] ((diff (spaceIndex 0))^[α 0]
    ((diff (spaceIndex 1))^[α 1] ((diff (spaceIndex 2))^[α 2] a)))

lemma mixed_vectorField (a : Fin 3 → Formula 5) (ν : ℝ) (l : ℕ) (α : MultiIndex)
    (t : ℝ) (ht : 0 ≤ t) (x : Space) :
    mixedD l α (vectorField a ν) t x = vectorField (fun j => (a j).mixed l α) ν t x := by
  have hsp (i : Fin 3) (n : ℕ) (a : Fin 3 → Formula 5) :
      (spatialD i)^[n] (vectorField a ν) = vectorField (fun j => (diff (spaceIndex i))^[n] (a j)) ν := by
    induction n with
    | zero => rfl
    | succ n ih => simp only [Function.iterate_succ_apply', ih, spatial_vectorField]
  have htime (n : ℕ) (a : Fin 3 → Formula 5) :
      ∀ s, 0 ≤ s → ∀ y, (timeD)^[n] (vectorField a ν) s y =
        vectorField (fun j => (diff 0)^[n] (a j)) ν s y := by
    induction n with
    | zero => intro s _ y; rfl
    | succ n ih =>
      intro s hs y
      rw [Function.iterate_succ_apply']
      have he : (fun r => (timeD)^[n] (vectorField a ν) r y) =ᶠ[𝓝[Ici 0] s]
          fun r => vectorField (fun j => (diff 0)^[n] (a j)) ν r y := by
        filter_upwards [self_mem_nhdsWithin] with r hr
        exact ih r hr y
      rw [timeD, he.derivWithin_eq_of_mem hs, ← timeD,
        time_vectorField _ _ _ hs]
      simp only [Function.iterate_succ_apply']
  unfold mixedD spatialMulti mixed
  rw [hsp, hsp, hsp]
  exact htime l _ t ht x

end Formula
end EffectiveProfile
end RapidForcing

end OAI