File size: 4,449 Bytes
695bd70 | 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 | import OAI.Geometry.Relativity.CKS.TailDifferentiation
import OAI.Geometry.Relativity.CKS.TailSymbols
namespace OAI
noncomputable section
namespace CKSADM
noncomputable section
open Set Filter Finset CKSSphericalHarmonics CKSInducedSphere CKSSphericalChart
open scoped Topology ContDiff
def angularPower (c : E → ℝ) (d : ℝ) (x : E) : ℝ := ‖x‖^(-d)*c (unitVector x)
def angularNext (c : E → ℝ) (d : ℝ) (j : Ix) (n : E) : ℝ :=
(-d*n j)*c n + ∑ i : Ix, ((if i=j then 1 else 0)-n i*n j)*pd i c n
lemma angularNext_smooth {c : E → ℝ} (hc : ContDiffOn ℝ ∞ c U) (d : ℝ) (j : Ix) :
ContDiffOn ℝ ∞ (angularNext c d j) U := by
apply ContDiffOn.add
· exact (contDiffOn_const.mul (coordinate_smooth j)).mul hc
· apply ContDiffOn.sum
intro i hi
exact (contDiffOn_const.sub ((coordinate_smooth i).mul (coordinate_smooth j))).mul
(partial_smooth hc i)
lemma angularPower_regular {c : E → ℝ} (hc : ContDiffOn ℝ ∞ c U) (d : ℝ) :
TailRegular (angularPower c d) := by
filter_upwards [eventually_norm_gt 0] with x hx
have hn : x ≠ 0 := norm_pos_iff.mp hx
have hh : ContDiffOn ℝ ∞ (fun z : ℝ × E => c z.2) heatDomain :=
hc.comp contDiffOn_snd (fun z hz => hz)
exact radialHeat_smooth (F := fun _ y => c y) hh 0 0 d hn
lemma angularPower_decay {c : E → ℝ} (hc : ContDiffOn ℝ ∞ c U) (d : ℝ) :
Decay d (angularPower c d) := by
let cr := smoothRestriction c hc
refine ⟨‖cr‖,norm_nonneg _,?_⟩
filter_upwards [eventually_norm_gt 0] with x hx
have hn := unitVector_norm (norm_pos_iff.mp hx)
let s : Sphere := ⟨unitVector x,by simpa [Metric.mem_sphere,dist_zero_right] using hn⟩
have hh : |c (unitVector x)| ≤ ‖cr‖ := cr.norm_coe_le_norm s
rw [angularPower,abs_mul,abs_of_nonneg (Real.rpow_nonneg (norm_nonneg _) _)]
exact (mul_le_mul_of_nonneg_left hh (Real.rpow_nonneg (norm_nonneg _) _)).trans_eq (mul_comm _ _)
lemma pd_angularPower {c : E → ℝ} (hc : ContDiffOn ℝ ∞ c U) (d : ℝ) {x : E} (hx : x ≠ 0) (j : Ix) :
pd j (angularPower c d) x = angularPower (angularNext c d j) (d+1) x := by
have hh : ContDiffOn ℝ ∞ (fun z : ℝ × E => c z.2) heatDomain :=
hc.comp contDiffOn_snd (fun z hz => hz)
have he := pd_radialHeat (F := fun _ y => c y) hh 0 0 d hx j
have heq : radialHeat (fun _ y => c y) 0 0 d = angularPower c d := rfl
rw [heq] at he
simpa only [radialHeat,radialNext,zero_mul,zero_add,add_zero,angularPower,angularNext] using he
theorem angularPower_symbol {c : E → ℝ} (hc : ContDiffOn ℝ ∞ c U) (d : ℝ) :
Symbol d (angularPower c d) := by
refine ⟨angularPower_regular hc d,?_⟩
intro n
induction n generalizing c d with
| zero => exact angularPower_decay hc d
| succ n ih =>
refine ⟨angularPower_decay hc d,?_⟩
intro j
apply (ih (angularNext_smooth hc d j) (d+1)).congr
filter_upwards [eventually_norm_gt 0] with x hx
exact (pd_angularPower hc d (norm_pos_iff.mp hx) j).symm
lemma norm_power_symbol (d : ℝ) : Symbol d (fun x : E => ‖x‖^(-d)) := by
have hh := angularPower_symbol (c := fun _ => 1) contDiffOn_const d
convert hh using 1
funext x
simp [angularPower]
lemma normal_symbol (i : Ix) : Symbol 0 (fun x : E => normal x i) := by
have hh := angularPower_symbol (coordinate_smooth i) 0
convert hh using 1
funext x
simp [angularPower,unitVector_component]
lemma SymbolN.word {F : E → ℝ} {d : ℝ} (hF : Symbol d F) (w : List Ix) :
Decay (d+w.length) (cartWord w F) := by
induction w generalizing F d with
| nil =>
simp only [cartWord,List.length_nil,Nat.cast_zero,add_zero]
exact hF.2 0
| cons j w ih =>
have hh := ih (hF.pd j)
convert hh using 1 <;> simp only [cartWord,List.length_cons,Nat.cast_add,Nat.cast_one]
ring
lemma symbol_of_words {F : E → ℝ} {d : ℝ} (hr : TailRegular F)
(hw : ∀ w : List Ix, Decay (d+w.length) (cartWord w F)) : Symbol d F := by
refine ⟨hr,?_⟩
intro n
induction n generalizing F d with
| zero =>
change Decay d F
simpa only [cartWord,List.length_nil,Nat.cast_zero,add_zero] using hw []
| succ n ih =>
refine ⟨?_,?_⟩
· simpa only [cartWord,List.length_nil,Nat.cast_zero,add_zero] using hw []
· intro j
apply ih (hr.pd j)
intro w
convert hw (j::w) using 1 <;> simp only [cartWord,List.length_cons,Nat.cast_add,Nat.cast_one]
ring
end
end CKSADM
end
end OAI
|