File size: 7,154 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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
import OAI.Geometry.Relativity.CKS.BoostTransport

namespace OAI

noncomputable section
namespace CKSLorentz
noncomputable section
open scoped RealInnerProductSpace ContDiff Topology
open Set MeasureTheory
open CKSSphericalHarmonics (puncturedSpace surfaceMeasure smoothRestriction)

def pullbackRate (p : E) (F : E → ℝ) (z : ℝ × E) : ℝ :=
  fderiv ℝ (normalizedPullback p F) z (1,0)

lemma normalizedDomain_open : IsOpen (Set.univ ×ˢ (puncturedSpace : Set E) : Set (ℝ × E)) :=
  isOpen_univ.prod puncturedSpace.isOpen

lemma pullbackRate_smooth (p : E) {F : E → ℝ} (hF : ContDiffOn ℝ ∞ F puncturedSpace) :
    ContDiffOn ℝ ∞ (pullbackRate p F) (Set.univ ×ˢ (puncturedSpace : Set E)) :=
  ((normalizedPullback_smooth p hF).fderiv_of_isOpen normalizedDomain_open (by simp)).clm_apply contDiffOn_const

lemma pullback_time_derivative (p : E) {F : E → ℝ} (hF : ContDiffOn ℝ ∞ F puncturedSpace)
    (t : ℝ) (n : Sphere) :
    HasDerivAt (fun t => normalizedPullback p F (t,(n:E))) (pullbackRate p F (t,(n:E))) t := by
  have hg := ((normalizedPullback_smooth p hF).contDiffAt (x := (t,(n:E)))
    (normalizedDomain_open.mem_nhds ⟨mem_univ t,CKSSphericalHarmonics.sphere_ne_zero n⟩)).differentiableAt (by simp)
  have hline : HasDerivAt (fun t : ℝ => (t,(n:E))) (1,0) t :=
    (hasDerivAt_id t).prodMk (hasDerivAt_const t (n:E))
  convert! hg.hasFDerivAt.comp_hasDerivAt t hline using 1

lemma pullbackRate_transport (p : E) {F : E → ℝ} (hF : ContDiffOn ℝ ∞ F puncturedSpace)
    (t : ℝ) (n : Sphere) :
    pullbackRate p F (t,(n:E)) =
      (flowEnergy p t)⁻¹ * (fderiv ℝ (fun x => normalizedPullback p F (t,x)) n (boostField p n) -
        2*inner ℝ p (n:E)*normalizedPullback p F (t,(n:E))) :=
  (pullback_time_derivative p hF t n).unique (normalizedPullback_transport p hF t n)

lemma continuous_restrict_sphere {G : ℝ × E → ℝ}
    (hG : ContDiffOn ℝ ∞ G (Set.univ ×ˢ (puncturedSpace : Set E))) :
    Continuous (fun z : ℝ × Sphere => G (z.1,(z.2:E))) := by
  apply continuous_iff_continuousAt.mpr
  intro z
  have hi : Continuous (fun z : ℝ × Sphere => (z.1,(z.2:E))) :=
    continuous_fst.prodMk (continuous_subtype_val.comp continuous_snd)
  have ho : ContinuousAt G (z.1,(z.2:E)) :=
    (hG.contDiffAt (x := (z.1,(z.2:E))) (normalizedDomain_open.mem_nhds
      ⟨mem_univ _, CKSSphericalHarmonics.sphere_ne_zero z.2⟩)).continuousAt
  exact ho.comp (f := fun z : ℝ × Sphere => (z.1,(z.2:E))) hi.continuousAt

lemma sphere_integrable_smooth {H : E → ℝ} (hH : ContDiffOn ℝ ∞ H puncturedSpace) :
    Integrable (fun n : Sphere => H n) surfaceMeasure :=
  (smoothRestriction H hH).continuous.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)

lemma boostField_smooth (p : E) : ContDiff ℝ ∞ (boostField p) :=
  contDiff_const.sub ((ContDiff.inner ℝ contDiff_const contDiff_id).smul contDiff_id)

lemma pullbackRate_integral_zero (p : E) {F : E → ℝ} (hF : ContDiffOn ℝ ∞ F puncturedSpace) (t : ℝ) :
    ∫ n : Sphere, pullbackRate p F (t,(n:E)) ∂surfaceMeasure = 0 := by
  let G : E → ℝ := fun x => normalizedPullback p F (t,x)
  have hG : ContDiffOn ℝ ∞ G puncturedSpace := normalizedPullback_spatial p hF t
  have hDG : ContDiffOn ℝ ∞ (fun x => fderiv ℝ G x (boostField p x)) puncturedSpace :=
    (hG.fderiv_of_isOpen puncturedSpace.isOpen (by simp)).clm_apply (boostField_smooth p).contDiffOn
  have hqG : ContDiffOn ℝ ∞ (fun x => inner ℝ p x * G x) puncturedSpace :=
    (ContDiff.inner ℝ contDiff_const contDiff_id).contDiffOn.mul hG
  have he : (fun n : Sphere => pullbackRate p F (t,(n:E))) =
      fun n : Sphere => (flowEnergy p t)⁻¹ * (fderiv ℝ G n (boostField p n) - 2*(inner ℝ p (n:E)*G n)) := by
    funext n
    rw [pullbackRate_transport p hF]
    dsimp only [G]; ring
  rw [he, integral_const_mul, integral_sub (sphere_integrable_smooth hDG) ((sphere_integrable_smooth hqG).const_mul 2), integral_const_mul]
  have hi := CKSSphericalHarmonics.sphereIntegral_boostField hG p
  change (∫ n : Sphere, fderiv ℝ G n (boostField p n) ∂surfaceMeasure) = _ at hi
  rw [hi]; ring

lemma normalizedIntegral_derivative_zero (p : E) {F : E → ℝ}
    (hF : ContDiffOn ℝ ∞ F puncturedSpace) (t₀ : ℝ) :
    HasDerivAt (fun t => ∫ n : Sphere, normalizedPullback p F (t,(n:E)) ∂surfaceMeasure) 0 t₀ := by
  let H (t : ℝ) (n : Sphere) := normalizedPullback p F (t,(n:E))
  let R (t : ℝ) (n : Sphere) := pullbackRate p F (t,(n:E))
  have hH : Continuous (fun z : ℝ × Sphere => H z.1 z.2) :=
    continuous_restrict_sphere (normalizedPullback_smooth p hF)
  have hR : Continuous (fun z : ℝ × Sphere => R z.1 z.2) :=
    continuous_restrict_sphere (pullbackRate_smooth p hF)
  have hHt (t : ℝ) : Continuous (H t) := by
    have hc : Continuous (fun n : Sphere => (t,n)) := continuous_const.prodMk continuous_id
    exact Continuous.comp (f := fun n : Sphere => (t,n))
      (g := fun z : ℝ × Sphere => H z.1 z.2) hH hc
  have hRt (t : ℝ) : Continuous (R t) := by
    have hc : Continuous (fun n : Sphere => (t,n)) := continuous_const.prodMk continuous_id
    exact Continuous.comp (f := fun n : Sphere => (t,n))
      (g := fun z : ℝ × Sphere => R z.1 z.2) hR hc
  let K : Set (ℝ × Sphere) := Icc (t₀-1) (t₀+1) ×ˢ univ
  have hK : IsCompact K := isCompact_Icc.prod isCompact_univ
  obtain ⟨C,hC⟩ := hK.exists_bound_of_continuousOn hR.continuousOn
  have h := hasDerivAt_integral_of_dominated_loc_of_deriv_le
    (μ := surfaceMeasure) (x₀ := t₀) (s := Ioo (t₀-1) (t₀+1))
    (F := H) (F' := R) (bound := fun _ => C)
    (Ioo_mem_nhds (by linarith) (by linarith))
    (Filter.Eventually.of_forall fun t => (hHt t).aestronglyMeasurable)
    ((hHt t₀).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _))
    ((hRt t₀).aestronglyMeasurable)
    (Filter.Eventually.of_forall fun n t ht => hC (t,n) ⟨⟨ht.1.le,ht.2.le⟩, mem_univ n⟩)
    (integrable_const C)
    (Filter.Eventually.of_forall fun n t _ => pullback_time_derivative p hF t n)
  convert! h.2 using 1
  exact (pullbackRate_integral_zero p hF t₀).symm

theorem flow_area_substitution (p : E) {F : E → ℝ} (hF : ContDiffOn ℝ ∞ F puncturedSpace) (t : ℝ) :
    ∫ n : Sphere, (flowD p t n)⁻¹ ^2 * F (flowPhi p t n) ∂surfaceMeasure =
      ∫ n : Sphere, F n ∂surfaceMeasure := by
  let H (t : ℝ) (n : Sphere) := normalizedPullback p F (t,(n:E))
  have hd := normalizedIntegral_derivative_zero p hF
  have he := is_const_of_deriv_eq_zero (fun t => (hd t).differentiableAt) (fun t => (hd t).deriv) t 0
  have hzero : ∀ n : Sphere, H 0 n = F n := by
    intro n
    simp [H, normalizedPullback_sphere, weightedPullback, flowPhi, flowD, flowEnergy,
      flowS, flowCoeff]
  have ht : ∀ n : Sphere, H t n = (flowD p t n)⁻¹ ^2 * F (flowPhi p t n) := by
    intro n
    rw [show H t n = weightedPullback p t F n by exact normalizedPullback_sphere p F t n]
    rfl
  change (∫ n : Sphere, H t n ∂surfaceMeasure) = ∫ n : Sphere, H 0 n ∂surfaceMeasure at he
  simpa only [hzero,ht] using he

end
end CKSLorentz

end

end OAI