File size: 8,296 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 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 | import OAI.Geometry.IsometricImmersion.Taylor.ChainResidual
import Mathlib.Analysis.Calculus.FDeriv.Symmetric
namespace OAI
noncomputable section
open Set Function Filter
open scoped ContDiff Topology BigOperators Matrix
namespace SmoothLocal.HighEquation
theorem ChainWord.prepend_single (n : ℕ) :
(ChainWord.single n).prepend = ChainWord.pair 1 n := rfl
theorem ChainWord.bump_single (n : ℕ) :
(ChainWord.single n).bump (0 : Fin 1) = ChainWord.single (n + 1) := by
change ChainWord.mk 1 _ = ChainWord.mk 1 _
congr 1
ext i
fin_cases i
simp [ChainWord.single]
theorem ChainWord.prepend_pair (a b : ℕ) :
(ChainWord.pair a b).prepend = ChainWord.triple 1 a b := rfl
theorem ChainWord.bump_pair_zero (a b : ℕ) :
(ChainWord.pair a b).bump (0 : Fin 2) = ChainWord.pair (a + 1) b := by
apply congrArg (ChainWord.mk 2)
change Function.update (![a, b] : Fin 2 → ℕ) (0 : Fin 2) (a + 1) = ![a + 1, b]
funext i
fin_cases i <;> simp
theorem ChainWord.bump_pair_one (a b : ℕ) :
(ChainWord.pair a b).bump (1 : Fin 2) = ChainWord.pair a (b + 1) := by
change ChainWord.mk 2 _ = ChainWord.mk 2 _
congr 1
ext i
fin_cases i <;> simp [ChainWord.pair]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
theorem chainTerm_single_eq (F : E → ℝ) (J : ℝ → E) (n : ℕ) (t : ℝ) :
chainTerm F J (ChainWord.single n) t =
fderiv ℝ F (J t) (iteratedDeriv n J t) := by
simp only [chainTerm, ChainWord.single, Matrix.cons_val_fin_one]
exact iteratedFDeriv_one_apply (𝕜 := ℝ) (f := F) (x := J t)
(fun _ : Fin 1 => iteratedDeriv n J t)
theorem chainTerm_pair_eq (F : E → ℝ) (J : ℝ → E) (a b : ℕ) (t : ℝ) :
chainTerm F J (ChainWord.pair a b) t =
iteratedFDeriv ℝ 2 F (J t) ![iteratedDeriv a J t, iteratedDeriv b J t] := by
apply congrArg (iteratedFDeriv ℝ 2 F (J t))
ext i
fin_cases i <;> rfl
theorem chainTerm_triple_eq (F : E → ℝ) (J : ℝ → E) (a b c : ℕ) (t : ℝ) :
chainTerm F J (ChainWord.triple a b c) t =
iteratedFDeriv ℝ 3 F (J t)
![iteratedDeriv a J t, iteratedDeriv b J t, iteratedDeriv c J t] := by
apply congrArg (iteratedFDeriv ℝ 3 F (J t))
ext i
fin_cases i <;> rfl
theorem chainTerm_pair_symm {F : E → ℝ} (J : ℝ → E) {t : ℝ}
(hF : ContDiffAt ℝ ∞ F (J t)) (a b : ℕ) :
chainTerm F J (ChainWord.pair a b) t = chainTerm F J (ChainWord.pair b a) t := by
rw [chainTerm_pair_eq, chainTerm_pair_eq]
have hs := hF.isSymmSndFDerivAt (by
simp only [minSmoothness, ite_eq_left (inferInstance : IsRCLikeNormedField ℝ)]
exact WithTop.coe_le_coe.mpr le_top)
exact hs.iteratedFDeriv_cons
theorem chainTerm_single_hasDerivAt {F : E → ℝ} {J : ℝ → E} {t : ℝ}
(hF : ContDiffAt ℝ ∞ F (J t)) (hJ : ContDiffAt ℝ ∞ J t) (n : ℕ) :
HasDerivAt (chainTerm F J (ChainWord.single n))
(chainTerm F J (ChainWord.single (n + 1)) t +
chainTerm F J (ChainWord.pair 1 n) t) t := by
have h := chainTerm_hasDerivAt hF hJ (ChainWord.single n)
change HasDerivAt _
(chainTerm F J (ChainWord.single n).prepend t +
∑ i : Fin 1, chainTerm F J ((ChainWord.single n).bump i) t) t at h
simpa only [Fin.sum_univ_one, ChainWord.prepend_single, ChainWord.bump_single,
add_comm] using h
theorem chainTerm_pair_hasDerivAt {F : E → ℝ} {J : ℝ → E} {t : ℝ}
(hF : ContDiffAt ℝ ∞ F (J t)) (hJ : ContDiffAt ℝ ∞ J t) (a b : ℕ) :
HasDerivAt (chainTerm F J (ChainWord.pair a b))
(chainTerm F J (ChainWord.triple 1 a b) t +
chainTerm F J (ChainWord.pair (a + 1) b) t +
chainTerm F J (ChainWord.pair a (b + 1)) t) t := by
have h := chainTerm_hasDerivAt hF hJ (ChainWord.pair a b)
change HasDerivAt _
(chainTerm F J (ChainWord.pair a b).prepend t +
∑ i : Fin 2, chainTerm F J ((ChainWord.pair a b).bump i) t) t at h
simpa only [Fin.sum_univ_two, ChainWord.prepend_pair, ChainWord.bump_pair_zero,
ChainWord.bump_pair_one, add_assoc] using h
theorem top_chain_three {F : E → ℝ} {J : ℝ → E} {t : ℝ}
(hF : ContDiffAt ℝ ∞ F (J t)) (hJ : ContDiffAt ℝ ∞ J t) :
iteratedDeriv 3 (F ∘ J) t =
chainTerm F J (ChainWord.single 3) t +
3 * chainTerm F J (ChainWord.pair 1 2) t +
chainSum F J (topResidualWords 0) t := by
have h := iteratedDeriv_vcomp_three
(hF.of_le (WithTop.coe_le_coe.mpr le_top))
(hJ.of_le (WithTop.coe_le_coe.mpr le_top))
have heq : iteratedDeriv 3 (F ∘ J) t =
chainTerm F J (ChainWord.triple 1 1 1) t +
chainTerm F J (ChainWord.pair 2 1) t +
2 * chainTerm F J (ChainWord.pair 1 2) t +
chainTerm F J (ChainWord.single 3) t := by
rw [chainTerm_triple_eq, chainTerm_pair_eq, chainTerm_pair_eq, chainTerm_single_eq]
simp only [iteratedDeriv_one, two_smul, two_mul] at h ⊢
convert h using 1
have hv : (![deriv J t, deriv J t, deriv J t] : Fin 3 → E) = fun _ => deriv J t := by
funext i
fin_cases i <;> rfl
rw [hv]
rw [chainTerm_pair_symm J hF 2 1] at heq
simp only [topResidualWords, chainSum, List.map_cons, List.map_nil, List.sum_cons,
List.sum_nil, add_zero]
linarith [heq]
theorem top_chain_expansion
{F : E → ℝ} {J : ℝ → E} {O : Set E} {I : Set ℝ}
(hO : IsOpen O) (hI : IsOpen I) (hF : ContDiffOn ℝ ∞ F O)
(hJ : ContDiffOn ℝ ∞ J I) (hmap : MapsTo J I O) :
∀ m t, t ∈ I →
iteratedDeriv (m + 3) (F ∘ J) t =
chainTerm F J (ChainWord.single (m + 3)) t +
(m + 3 : ℝ) * chainTerm F J (ChainWord.pair 1 (m + 2)) t +
chainSum F J (topResidualWords m) t := by
intro m
induction m with
| zero =>
intro t ht
simpa only [Nat.zero_add, Nat.cast_zero, zero_add] using top_chain_three (hF.contDiffAt (hO.mem_nhds (hmap ht)))
(hJ.contDiffAt (hI.mem_nhds ht))
| succ m ih =>
intro t ht
have hFt := hF.contDiffAt (hO.mem_nhds (hmap ht))
have hJt := hJ.contDiffAt (hI.mem_nhds ht)
have heq : iteratedDeriv (m + 3) (F ∘ J) =ᶠ[𝓝 t]
(fun r => chainTerm F J (ChainWord.single (m + 3)) r +
(m + 3 : ℝ) * chainTerm F J (ChainWord.pair 1 (m + 2)) r +
chainSum F J (topResidualWords m) r) := by
filter_upwards [hI.mem_nhds ht] with r hr
exact ih r hr
have hd := ((chainTerm_single_hasDerivAt hFt hJt (m + 3)).add
((chainTerm_pair_hasDerivAt hFt hJt 1 (m + 2)).const_mul (m + 3 : ℝ))).add
(chainSum_hasDerivAt hFt hJt (topResidualWords m))
have hd' := hd.deriv
change deriv (fun r => chainTerm F J (ChainWord.single (m + 3)) r +
(m + 3 : ℝ) * chainTerm F J (ChainWord.pair 1 (m + 2)) r +
chainSum F J (topResidualWords m) r) t = _ at hd'
rw [show m + 1 + 3 = (m + 3) + 1 by omega, iteratedDeriv_succ, heq.deriv_eq, hd']
rw [topResidualWords_sum_succ]
simp only [Nat.cast_add, Nat.add_assoc, Nat.reduceAdd]
ring
theorem actualP_top_chain_expansion
{g : SmoothLocal.Geometry.MetricField} {z : SmoothLocal.Geometry.Coord → ℝ}
{U : Set SmoothLocal.Geometry.Coord} {x y : ℝ}
(hg : SmoothLocal.Geometry.SmoothPositiveOn g U) (hU : IsOpen U)
(hz : ContDiffOn ℝ ∞ z U)
(hyy : ∀ p ∈ U, SmoothLocal.Geometry.covHessian g z p 1 1 ≠ 0)
(hp : (![x, y] : SmoothLocal.Geometry.Coord) ∈ U) (m : ℕ) :
iteratedDeriv (m + 3) (sixVariableP g ∘ solutionJetCurve z x) y =
chainTerm (sixVariableP g) (solutionJetCurve z x) (ChainWord.single (m + 3)) y +
(m + 3 : ℝ) * chainTerm (sixVariableP g) (solutionJetCurve z x)
(ChainWord.pair 1 (m + 2)) y +
chainSum (sixVariableP g) (solutionJetCurve z x) (topResidualWords m) y := by
let I : Set ℝ := {t | (![x, t] : SmoothLocal.Geometry.Coord) ∈ U}
have hI : IsOpen I := hU.preimage (verticalPoint_contDiff x).continuous
have hJ : ContDiffOn ℝ ∞ (solutionJetCurve z x) I := by
intro t ht
exact (solutionJetCurve_contDiffAt hU hz ht).contDiffWithinAt
have hmap : MapsTo (solutionJetCurve z x) I (darbouxStateDomain g U) := by
intro t ht
exact solutionJet_mem_domain g z ht (hyy _ ht)
exact top_chain_expansion (darbouxStateDomain_isOpen hg hU) hI
(sixVariableP_contDiffOn hg hU) hJ hmap m y hp
end SmoothLocal.HighEquation
end
end OAI
|