File size: 4,627 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
import Mathlib
import OAI.Analysis.HardSphere.Geometry.CoordinateLine
import OAI.Analysis.HardSphere.Geometry.NormSqIntegral

namespace OAI

noncomputable section
open MeasureTheory Filter Set
open scoped ENNReal Topology BigOperators
open scoped BigOperators ComplexConjugate
open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators
open MeasureTheory ProbabilityTheory Real Complex
open scoped ENNReal ComplexConjugate
open ProbabilityTheory
namespace HardSphere
open MeasureTheory Filter Set

lemma smooth_insertNth {n : β„•} (j : Fin (n+1)) (x : Fin 3 β†’ ℝ) :
    ContDiff ℝ ((⊀ : β„•βˆž) : WithTop β„•βˆž)
      (fun Y : LiftedConfiguration n ↦ Fin.insertNth (Ξ± := fun _ ↦ Fin 3 β†’ ℝ) j x Y) := by
  apply contDiff_pi.mpr
  intro i
  induction i using j.succAboveCases with
  | x => simpa only [Fin.insertNth_apply_same] using
      (contDiff_const : ContDiff ℝ ((⊀ : β„•βˆž) : WithTop β„•βˆž) (fun _ : LiftedConfiguration n ↦ x))
  | p i => simpa only [Fin.insertNth_apply_succAbove] using
      (contDiff_apply ℝ (Fin 3 β†’ ℝ) i)

lemma smooth_slice {n : β„•} {L : Length} {a : ℝ} (f : SmoothTest (n+1) L a)
    (j : Fin (n+1)) (x : Torus L) :
    ContDiff ℝ ((⊀ : β„•βˆž) : WithTop β„•βˆž)
      (fun Y : LiftedConfiguration n ↦ f.toFun (j.insertNth x (project n L Y))) := by
  have h := f.smooth.comp (smooth_insertNth j (representative 1 L (fun _ ↦ x) 0))
  convert h using 1
  funext Y
  congr 1
  ext i q
  induction i using j.succAboveCases with
  | x =>
    simp only [project,Fin.insertNth_apply_same]
    exact (congr_fun (congr_fun (project_representative 1 L (fun _ ↦ x)) 0) q).symm
  | p i => simp only [project,Fin.insertNth_apply_succAbove]

lemma insertNth_coordinateLine {n : β„•} {L : Length} (j : Fin (n+1)) (x : Torus L)
    (Y : Configuration n L) (p : Direction n) (t : AddCircle L.val) :
    j.insertNth x (coordinateLine Y p t)=coordinateLine (j.insertNth x Y) (j.succAbove p.1,p.2) t := by
  ext i q
  induction i using j.succAboveCases with
  | x => simp [coordinateLine]
  | p i => simp [coordinateLine,Pi.single_apply,Fin.succAbove_inj]

lemma coordDerivative_slice {n : β„•} {L : Length} {a : ℝ} (f : SmoothTest (n+1) L a)
    (j : Fin (n+1)) (x : Torus L) (p : Direction n) :
    coordDerivative n L (fun Y ↦ f.toFun (j.insertNth x Y)) p=
      fun Y ↦ coordDerivative (n+1) L f.toFun (j.succAbove p.1,p.2) (j.insertNth x Y) := by
  funext Y
  have h1 := hasDerivAt_coordinateLine (f := fun Y ↦ f.toFun (j.insertNth x Y)) ((smooth_slice f j x).differentiable (by simp)) Y p 0
  have h2 := hasDerivAt_coordinateLine (f.smooth.differentiable (by simp))
    (j.insertNth x Y) (j.succAbove p.1,p.2) 0
  simp only [insertNth_coordinateLine] at h1
  have h := h1.unique h2
  simpa [coordinateLine] using h

def SmoothTest.slice {n : β„•} {L : Length} {a : ℝ} (f : SmoothTest (n+1) L a)
    (j : Fin (n+1)) (x : Torus L) : SmoothTest n L a where
  toFun Y := f.toFun (j.insertNth x Y)
  smooth := smooth_slice f j x
  compact := HasCompactSupport.of_compactSpace _
  support_allowed := by
    intro Y hY i k hik
    have h := f.support_allowed (tsupport_comp_subset_preimage f.toFun
      (Continuous.finInsertNth j (continuous_const : Continuous (fun _ : Configuration n L ↦ x)) continuous_id) hY)
    simpa only [Fin.insertNth_apply_succAbove,id_eq] using h (j.succAbove i) (j.succAbove k)
      (Fin.strictMono_succAbove j hik)
  memLp := (f.continuous.comp (Continuous.finInsertNth j (continuous_const : Continuous (fun _ : Configuration n L ↦ x)) continuous_id)).memLp_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)
  partial_memLp := fun p ↦ by
    rw [coordDerivative_slice]
    exact ((f.continuous_partial (j.succAbove p.1,p.2)).comp
      (Continuous.finInsertNth j (continuous_const : Continuous (fun _ : Configuration n L ↦ x)) continuous_id)).memLp_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)

lemma smoothTest_norm_sq {n : β„•} {L : Length} {a : ℝ} (f : SmoothTest n L a) :
    β€–f.jet.1β€–^2=∫ X : Configuration n L, β€–f.toFun Xβ€–^2 := by
  rw [IndicatorStrong.norm_sq_integral]
  exact integral_congr_ae ((MemLp.coeFn_toLp f.memLp).fun_comp (fun z : β„‚ ↦ β€–zβ€–^2))

lemma smoothTest_partial_norm_sq {n : β„•} {L : Length} {a : ℝ} (f : SmoothTest n L a)
    (p : Direction n) :
    β€–f.jet.2 pβ€–^2=∫ X : Configuration n L, β€–coordDerivative n L f.toFun p Xβ€–^2 := by
  rw [IndicatorStrong.norm_sq_integral]
  exact integral_congr_ae ((MemLp.coeFn_toLp (f.partial_memLp p)).fun_comp (fun z : β„‚ ↦ β€–zβ€–^2))

end HardSphere

end

end OAI