| import Mathlib |
| import OAI.Analysis.HardSphere.Bridges.PartialIndex |
| import OAI.Analysis.HardSphere.Geometry.ConfigurationPath |
|
|
| 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 |
| namespace HardSphere.FreeFourier |
| lemma argument_add (L : ℝ) (n : ℤ) (x y : AddCircle L) : |
| fourier n (x+y) = fourier n x * fourier n y := by |
| simp only [fourier_apply, smul_add, AddCircle.toCircle_add, Circle.coe_mul] |
|
|
| lemma gaussian_character (L : ℝ) (n : ℤ) (t : ℝ) (ht : 0 ≤ t) : |
| (∫ x : ℝ, fourier n ((Real.sqrt (2*t) * x : ℝ) : AddCircle L) |
| ∂gaussianReal 0 1) = (Real.exp (-t * (2*Real.pi*n/L)^2) : ℂ) := by |
| have h := charFun_gaussianReal (μ := 0) (v := 1) ((2*Real.pi*n/L)*Real.sqrt (2*t)) |
| rw [charFun_apply_real] at h |
| have he (x : ℝ) : fourier n ((Real.sqrt (2*t)*x : ℝ) : AddCircle L) = |
| Complex.exp (((2*Real.pi*n/L)*Real.sqrt (2*t)*x : ℝ) * Complex.I) := by |
| rw [fourier_coe_apply] |
| push_cast |
| congr 1 |
| ring |
| simp_rw [he] |
| simp only [Complex.ofReal_mul] at h ⊢ |
| rw [h, Complex.ofReal_exp] |
| congr 1 |
| have hs := Real.sq_sqrt (show 0 ≤ 2*t by positivity) |
| push_cast at hs ⊢ |
| simp only [mul_zero, zero_mul, one_mul, zero_sub] |
| rw [mul_pow] |
| norm_cast at hs |
| have hs' : (Real.sqrt (2*t) : ℂ)^2 = 2*t := by exact_mod_cast hs |
| rw [hs'] |
| ring |
| end HardSphere.FreeFourier |
|
|
| namespace HardSphere |
| open Wiener ProbabilityTheory |
| open scoped ComplexConjugate |
|
|
| def configurationCharacter (N : ℕ) (L : Length) (k : Direction N → ℤ) : |
| C(Configuration N L, ℂ) where |
| toFun X := ∏ p : Direction N, fourier (k p) (X p.1 p.2) |
| continuous_toFun := by fun_prop |
|
|
| lemma configurationCharacter_norm (N : ℕ) (L : Length) (k : Direction N → ℤ) |
| (X : Configuration N L) : ‖configurationCharacter N L k X‖ = 1 := by |
| simp only [configurationCharacter, ContinuousMap.coe_mk, norm_prod, fourier_apply, |
| Circle.norm_coe, Finset.prod_const_one] |
|
|
| lemma configurationCharacter_add_argument (N : ℕ) (L : Length) (k : Direction N → ℤ) |
| (X Y : Configuration N L) : |
| configurationCharacter N L k (X+Y) = |
| configurationCharacter N L k X * configurationCharacter N L k Y := by |
| simp only [configurationCharacter, ContinuousMap.coe_mk, Pi.add_apply, |
| FreeFourier.argument_add, Finset.prod_mul_distrib] |
|
|
| lemma wiener_endpoint_law : HasLaw (fun w : C(Time,ℝ) ↦ w 1) (gaussianReal 0 1) wiener := by |
| simpa using wiener_projection_law (ι := Unit) (fun _ ↦ (1:ℝ)) (fun _ ↦ (1:Time)) |
|
|
| lemma wiener_character (L : Length) (n : ℤ) (t : ℝ) (ht : 0 ≤ t) : |
| (∫ w : C(Time,ℝ), fourier n ((Real.sqrt (2*t)*w 1 : ℝ) : AddCircle L.val) ∂wiener) = |
| (Real.exp (-t*(2*Real.pi*n/L.val)^2) : ℂ) := by |
| have hcont : Continuous (fun x : ℝ ↦ fourier n ((Real.sqrt (2*t)*x : ℝ) : AddCircle L.val)) := by |
| fun_prop |
| exact (wiener_endpoint_law.integral_comp hcont.aestronglyMeasurable).trans |
| (FreeFourier.gaussian_character L.val n t ht) |
|
|
| def fourierEnergy (N : ℕ) (L : Length) (k : Direction N → ℤ) : ℝ := |
| ∑ p : Direction N, (((2 : ℕ) : ℝ)*Real.pi*k p/L.val)^2 |
|
|
| lemma fourierEnergy_nonneg (N : ℕ) (L : Length) (k : Direction N → ℤ) : |
| 0 ≤ fourierEnergy N L k := Finset.sum_nonneg fun _ _ ↦ sq_nonneg _ |
|
|
| lemma freeTrajectory_character_integral (N : ℕ) (L : Length) (k : Direction N → ℤ) |
| (t : ℝ) (ht : 0 ≤ t) (X : Configuration N L) : |
| (∫ w, configurationCharacter N L k (freeTrajectory N L t w X 1) ∂coordinateWiener N) = |
| configurationCharacter N L k X * (Real.exp (-t * fourierEnergy N L k) : ℂ) := by |
| have hpoint (w : CoordinatePaths N) : |
| configurationCharacter N L k (freeTrajectory N L t w X 1) = |
| configurationCharacter N L k X * |
| ∏ p : Direction N, fourier (k p) ((Real.sqrt (2*t)*w p 1 : ℝ) : AddCircle L.val) := by |
| simp only [configurationCharacter, freeTrajectory, ContinuousMap.coe_mk, |
| FreeFourier.argument_add, Finset.prod_mul_distrib] |
| simp_rw [hpoint] |
| rw [integral_const_mul] |
| congr 1 |
| rw [coordinateWiener, integral_fintype_prod_eq_prod |
| (fun p (w : C(Time,ℝ)) ↦ fourier (k p) ((Real.sqrt (2*t)*w 1 : ℝ) : AddCircle L.val))] |
| simp_rw [wiener_character L _ t ht] |
| rw [← Complex.ofReal_prod, ← Real.exp_sum] |
| congr 2 |
| simp only [fourierEnergy, Nat.cast_ofNat, Finset.mul_sum] |
|
|
| end HardSphere |
|
|
| namespace HardSphere |
| open scoped ComplexConjugate |
| open Submodule Algebra |
| lemma configurationCharacter_neg (N : ℕ) (L : Length) (k : Direction N → ℤ) |
| (X : Configuration N L) : |
| configurationCharacter N L (-k) X = conj (configurationCharacter N L k X) := by |
| simp only [configurationCharacter, Pi.neg_apply, fourier_neg, ContinuousMap.coe_mk, map_prod] |
|
|
| lemma configurationCharacter_add (N : ℕ) (L : Length) (k l : Direction N → ℤ) |
| (X : Configuration N L) : |
| configurationCharacter N L (k+l) X = |
| configurationCharacter N L k X * configurationCharacter N L l X := by |
| simp only [configurationCharacter, Pi.add_apply, fourier_add, ContinuousMap.coe_mk, |
| Finset.prod_mul_distrib] |
|
|
| lemma configurationCharacter_zero (N : ℕ) (L : Length) : |
| configurationCharacter N L (0 : Direction N → ℤ) = 1 := by |
| ext X |
| simp only [configurationCharacter, Pi.zero_apply, fourier_zero, Finset.prod_const_one, |
| ContinuousMap.coe_mk, ContinuousMap.one_apply] |
|
|
| lemma configurationCharacter_single (N : ℕ) (L : Length) (p : Direction N) |
| (X : Configuration N L) : |
| configurationCharacter N L (Pi.single p 1) X = fourier 1 (X p.1 p.2) := by |
| classical |
| change (∏ q : Direction N, fourier ((Pi.single p 1 : Direction N → ℤ) q) (X q.1 q.2)) = _ |
| rw [Finset.prod_eq_single p] |
| · simp |
| · intro q _ hqp |
| simp only [Pi.single_eq_of_ne hqp, fourier_zero] |
| · simp |
|
|
| def characterAlgebra (N : ℕ) (L : Length) : StarSubalgebra ℂ C(Configuration N L, ℂ) where |
| toSubalgebra := Algebra.adjoin ℂ (range (configurationCharacter N L)) |
| star_mem' := by |
| change Algebra.adjoin ℂ (range (configurationCharacter N L)) ≤ |
| star (Algebra.adjoin ℂ (range (configurationCharacter N L))) |
| refine adjoin_le ?_ |
| rintro _ ⟨k,rfl⟩ |
| refine subset_adjoin ⟨-k, ?_⟩ |
| ext X |
| simp only [configurationCharacter_neg, starRingEnd_apply, ContinuousMap.star_apply] |
| |
| lemma characterAlgebra_eq_span (N : ℕ) (L : Length) : |
| (characterAlgebra N L).toSubalgebra.toSubmodule = |
| span ℂ (range (configurationCharacter N L)) := by |
| apply adjoin_eq_span_of_subset |
| refine .trans (fun x ↦ Submonoid.closure_induction (fun _ ↦ id) ⟨0, ?_⟩ ?_) subset_span |
| · exact configurationCharacter_zero N L |
| · rintro _ _ _ _ ⟨k,rfl⟩ ⟨l,rfl⟩ |
| exact ⟨k+l,ContinuousMap.ext fun X ↦ configurationCharacter_add N L k l X⟩ |
| |
| lemma characterAlgebra_separates (N : ℕ) (L : Length) : |
| (characterAlgebra N L).SeparatesPoints := by |
| classical |
| intro X Y hXY |
| obtain ⟨i,hi⟩ := Function.ne_iff.mp hXY |
| obtain ⟨j,hj⟩ := Function.ne_iff.mp hi |
| refine ⟨_, ⟨configurationCharacter N L (Pi.single (i,j) 1), |
| subset_adjoin ⟨Pi.single (i,j) 1,rfl⟩,rfl⟩, ?_⟩ |
| dsimp only |
| rw [configurationCharacter_single, configurationCharacter_single, fourier_one, fourier_one] |
| exact fun h ↦ hj (AddCircle.injective_toCircle L.property.ne' (Circle.coe_injective h)) |
|
|
| lemma character_span_dense (N : ℕ) (L : Length) : |
| (span ℂ (range (configurationCharacter N L))).topologicalClosure = ⊤ := by |
| rw [← characterAlgebra_eq_span] |
| exact congrArg (Subalgebra.toSubmodule ∘ StarSubalgebra.toSubalgebra) |
| (ContinuousMap.starSubalgebra_topologicalClosure_eq_top_of_separatesPoints _ |
| (characterAlgebra_separates N L)) |
|
|
| section |
|
|
| attribute [local instance] scalarL2_addCommMonoid scalarL2_module |
|
|
| local instance complexBoundedSMul : IsBoundedSMul ℂ ℂ := inferInstance |
|
|
| def characterL2 (N : ℕ) (L : Length) (k : Direction N → ℤ) : ScalarL2 N L := |
| DFunLike.coe (F := C(Configuration N L, ℂ) →L[ℂ] ScalarL2 N L) |
| (β := fun _ ↦ ScalarL2 N L) |
| (@ContinuousMap.toLp _ ℂ _ _ volume _ _ _ _ _ _ ℂ _ _ _ complexBoundedSMul) |
| (configurationCharacter N L k) |
|
|
| end |
|
|
| lemma characterL2_ae (N : ℕ) (L : Length) (k : Direction N → ℤ) : |
| characterL2 N L k =ᵐ[volume] configurationCharacter N L k := |
| ContinuousMap.coeFn_toLp volume _ |
|
|
| lemma characterL2_span_dense (N : ℕ) (L : Length) : |
| (span ℂ (range (characterL2 N L))).topologicalClosure = ⊤ := by |
| convert (ContinuousMap.toLp_denseRange ℂ (volume : Measure (Configuration N L)) ℂ |
| (show (2:ℝ≥0∞) ≠ ∞ by norm_num)).topologicalClosure_map_submodule |
| (character_span_dense N L) using 1 |
| rw [map_span] |
| unfold characterL2 |
| rw [range_comp'] |
| rfl |
| |
| end HardSphere |
| |
| end |
| |
| end OAI |
| |
