| import OAI.Geometry.Relativity.CKS.BoostFlow |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace CKSSphericalHarmonics |
| noncomputable section |
| open scoped RealInnerProductSpace ContDiff |
| open Finset |
|
|
| def boostField (p x : Ambient) : Ambient := p - inner ℝ p x • x |
|
|
| def coordinateCM (i : Fin 3) : C(Sphere,ℝ) := |
| smoothRestriction (fun x : Ambient => x i) (EuclideanSpace.proj (𝕜 := ℝ) i).contDiff.contDiffOn |
|
|
| lemma smoothRotation_coordinate (i j k : Fin 3) (x : Ambient) : |
| smoothRotation i j (fun x : Ambient => x k) x = |
| (if k=j then x i else 0) - (if k=i then x j else 0) := by |
| change fderiv ℝ (EuclideanSpace.proj (𝕜 := ℝ) k) x _ = _ |
| rw [(EuclideanSpace.proj (𝕜 := ℝ) k).fderiv] |
| exact rotationGenerator_apply i j k x |
|
|
| lemma sphereIntegral_coordinate_rotation {F : Ambient → ℝ} |
| (hF : ContDiffOn ℝ ∞ F puncturedSpace) (i j : Fin 3) : |
| sphereIntegral (coordinateCM i * |
| smoothRestriction (smoothRotation i j F) (smoothRotation_smooth hF i j)) = |
| if i=j then 0 else sphereIntegral (coordinateCM j * smoothRestriction F hF) := by |
| by_cases hij : i=j |
| · subst j |
| have hzero : smoothRestriction (smoothRotation i i F) (smoothRotation_smooth hF i i) = 0 := by |
| ext n |
| change fderiv ℝ F n (rotationGenerator i i n) = 0 |
| have hgen : rotationGenerator i i (n:Ambient) = 0 := by ext k; simp [rotationGenerator_apply] |
| rw [hgen, map_zero] |
| simp [hzero] |
| have h := smoothRotation_skew_adjoint (F := fun x : Ambient => x i) (G := F) |
| (EuclideanSpace.proj (𝕜 := ℝ) i).contDiff.contDiffOn hF i j hij |
| rw [inner_toL2, inner_toL2] at h |
| have he : smoothRestriction (smoothRotation i j (fun x : Ambient => x i)) |
| (smoothRotation_smooth (EuclideanSpace.proj (𝕜 := ℝ) i).contDiff.contDiffOn i j) = -coordinateCM j := by |
| ext n |
| change smoothRotation i j (fun x : Ambient => x i) n = -(n:Ambient) j |
| simp [smoothRotation_coordinate, hij] |
| rw [he] at h |
| simp only [neg_mul, map_neg] at h |
| simpa [hij, coordinateCM] using neg_injective h.symm |
|
|
| lemma boostField_decomposition (p : Ambient) (n : Sphere) : |
| boostField p n = ∑ i : Fin 3, ∑ j : Fin 3, |
| ((n:Ambient) i * p j) • rotationGenerator i j n := by |
| have h := rotationGenerator_decomposition (n:Ambient) p |
| have hn : ‖(n:Ambient)‖ = 1 := by simp |
| rw [hn, one_pow, one_smul] at h |
| have hi : inner ℝ p (n:Ambient) = ∑ i : Fin 3, (n:Ambient) i * p i := by |
| rw [PiLp.inner_apply] |
| simp [mul_comm] |
| unfold boostField |
| rw [hi] |
| exact sub_eq_iff_eq_add.mpr h |
|
|
| theorem sphereIntegral_boostField {F : Ambient → ℝ} |
| (hF : ContDiffOn ℝ ∞ F puncturedSpace) (p : Ambient) : |
| ∫ n : Sphere, fderiv ℝ F n (boostField p n) ∂surfaceMeasure = |
| 2 * ∫ n : Sphere, inner ℝ p (n:Ambient) * F n ∂surfaceMeasure := by |
| let L : C(Sphere,ℝ) := ∑ i : Fin 3, ∑ j : Fin 3, |
| p j • (coordinateCM i * smoothRestriction (smoothRotation i j F) (smoothRotation_smooth hF i j)) |
| have hL : ∀ n : Sphere, L n = fderiv ℝ F n (boostField p n) := by |
| intro n |
| rw [boostField_decomposition] |
| simp only [map_sum, map_smul, L, ContinuousMap.sum_apply, ContinuousMap.smul_apply, |
| ContinuousMap.mul_apply, smul_eq_mul, coordinateCM, smoothRestriction, smoothRotation, ContinuousMap.coe_mk] |
| apply sum_congr rfl; intro i hi |
| apply sum_congr rfl; intro j hj |
| ring |
| have hi : ∫ n : Sphere, fderiv ℝ F n (boostField p n) ∂surfaceMeasure = sphereIntegral L := by |
| rw [sphereIntegral_apply] |
| apply MeasureTheory.integral_congr_ae |
| exact Filter.Eventually.of_forall fun n => (hL n).symm |
| rw [hi] |
| have hsig : sphereIntegral L = |
| 2 * sphereIntegral ((∑ j : Fin 3, p j • coordinateCM j) * smoothRestriction F hF) := by |
| simp only [L, map_sum, map_smul, smul_eq_mul, sphereIntegral_coordinate_rotation hF] |
| simp only [Fin.sum_univ_three] |
| simp only [Fin.reduceEq, ite_true, ite_false, mul_zero, zero_add, add_zero] |
| rw [add_mul, add_mul, smul_mul_assoc, smul_mul_assoc, smul_mul_assoc] |
| simp only [map_add, map_smul, smul_eq_mul] |
| ring |
| rw [hsig, sphereIntegral_apply] |
| congr 1 |
| apply MeasureTheory.integral_congr_ae |
| filter_upwards [] with n |
| simp only [ContinuousMap.mul_apply, ContinuousMap.sum_apply, ContinuousMap.smul_apply, |
| smul_eq_mul, coordinateCM, smoothRestriction, ContinuousMap.coe_mk] |
| congr 1 |
| rw [PiLp.inner_apply] |
| simp [mul_comm] |
|
|
| end |
| end CKSSphericalHarmonics |
|
|
| end |
|
|
| end OAI |
|
|
