| import Mathlib |
| import OAI.Analysis.HardSphere.Geometry.GroundPathWeight |
| import OAI.Analysis.HardSphere.Bridges.TorusLocalBridge |
| import OAI.Analysis.HardSphere.Geometry.LocalAE |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open MeasureTheory MeasureTheory.Measure Set Filter |
| open scoped ENNReal NNReal Topology BigOperators ComplexConjugate |
| namespace HardSphere |
| open Wiener |
|
|
| lemma IsGroundVector.ae_killed_zero_propagation {N : ℕ} {L : Length} {a t : ℝ} |
| {u : Jet N L} (hu : IsGroundVector N L a u) (ht : 0≤t) : |
| ∀ᵐ ω ∂killedPathLaw N L a t, u.1 (ω 0)=0 → u.1 (ω 1)=0 := by |
| let Z : Set (Configuration N L) := {X | u.1 X=0} |
| have hZ : MeasurableSet Z := (Lp.stronglyMeasurable u.1).measurable (measurableSet_singleton 0) |
| let f : Configuration N L → ℂ := Z.indicator (fun _ ↦ 1) |
| have hf : MemLp f 2 volume := (memLp_const (1:ℂ)).indicator hZ |
| let F : ScalarL2 N L := hf.toLp f |
| have hF : F =ᵐ[volume] f := MemLp.coeFn_toLp hf |
| have hInner : inner ℂ F (modulusScalar u.1)=0 := by |
| rw [L2.inner_def] |
| apply integral_eq_zero_of_ae |
| filter_upwards [hF,coe_modulusScalar u.1] with X hX hM |
| simp only [RCLike.inner_apply,hX,hM] |
| by_cases hz : u.1 X=0 |
| · simp [hz] |
| · simp [f,Z,hz] |
| have hi := integrable_killed_endpoints N L a t F (modulusScalar u.1) 0 1 |
| have he : (∫ω, conj (F (ω 0))*modulusScalar u.1 (ω 1) ∂killedPathLaw N L a t)=0 := by |
| rw [←killedTransition_pairing,show modulusScalar u.1=(modulusJet u).1 from rfl, |
| hu.modulus.killed_eigenvector ht,inner_smul_right] |
| change _ * inner ℂ F (modulusScalar u.1)=0 |
| rw [hInner,mul_zero] |
| let g : ConfigurationPath N L → ℝ := fun ω ↦ if u.1 (ω 0)=0 then ‖u.1 (ω 1)‖ else 0 |
| have hg : (fun ω ↦ conj (F (ω 0))*modulusScalar u.1 (ω 1)) =ᵐ[killedPathLaw N L a t] |
| fun ω ↦ (g ω:ℂ) := by |
| filter_upwards [ae_restrict_of_ae ((freePathLaw_marginal N L t 0).quasiMeasurePreserving.ae_eq_comp hF), |
| ae_restrict_of_ae ((freePathLaw_marginal N L t 1).quasiMeasurePreserving.ae_eq_comp (coe_modulusScalar u.1))] with ω h0 h1 |
| dsimp only [Function.comp_def] at h0 h1 |
| rw [h0,h1] |
| by_cases hz : u.1 (ω 0)=0 <;> simp [f,Z,g,hz] |
| have hig : Integrable g (killedPathLaw N L a t) := |
| (Complex.reCLM.integrable_comp (hi.congr hg)).congr (Eventually.of_forall fun _ ↦ rfl) |
| have heg : ∫ω,g ω ∂killedPathLaw N L a t=0 := by |
| have hh := congrArg Complex.re ((integral_congr_ae hg).symm.trans he) |
| exact (Complex.reCLM.integral_comp_comm (hi.congr hg)).trans hh |
| have hgn : ∀ᵐ ω ∂killedPathLaw N L a t, 0≤g ω := ae_of_all _ (fun ω ↦ by dsimp [g]; split_ifs <;> positivity) |
| have hz := (integral_eq_zero_iff_of_nonneg_ae hgn hig).mp heg |
| filter_upwards [hz] with ω hω h0 |
| have hn : ‖u.1 (ω 1)‖=0 := by simpa [g,h0] using hω |
| exact norm_eq_zero.mp hn |
|
|
| def complexPhase (z : ℂ) : ℂ := z/(‖z‖:ℂ) |
|
|
| lemma complexPhase_eq_of_inner {z w : ℂ} (hz : z≠0) (hw : w≠0) |
| (h : conj z*w=(‖z‖*‖w‖:ℝ)) : complexPhase z=complexPhase w := by |
| have hnz : (‖z‖:ℂ)≠0 := Complex.ofReal_ne_zero.mpr (norm_ne_zero_iff.mpr hz) |
| have hnw : (‖w‖:ℂ)≠0 := Complex.ofReal_ne_zero.mpr (norm_ne_zero_iff.mpr hw) |
| apply (div_eq_div_iff hnz hnw).mpr |
| have hh := congrArg (fun u : ℂ ↦ z*u) h |
| rw [←mul_assoc,Complex.mul_conj',Complex.ofReal_mul] at hh |
| apply mul_left_cancel₀ hnz |
| calc |
| (‖z‖:ℂ)*(z*(‖w‖:ℂ))=z*((‖z‖:ℂ)*(‖w‖:ℂ)) := by ring |
| _ = (‖z‖:ℂ)^2*w := hh.symm |
| _ = (‖z‖:ℂ)*(w*(‖z‖:ℂ)) := by ring |
| |
| lemma complexPhase_mul_norm (z : ℂ) : complexPhase z*(‖z‖:ℂ)=z := by |
| by_cases hz : z=0 |
| · simp [complexPhase,hz] |
| · exact div_mul_cancel₀ _ (Complex.ofReal_ne_zero.mpr (norm_ne_zero_iff.mpr hz)) |
| |
| lemma norm_complexPhase {z : ℂ} (hz : z≠0) : ‖complexPhase z‖=1 := by |
| rw [complexPhase,norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (norm_nonneg _)] |
| exact div_self (norm_ne_zero_iff.mpr hz) |
| |
| lemma inner_eq_of_complexPhase_eq {z w : ℂ} (h : complexPhase z=complexPhase w) : |
| conj z*w=(‖z‖*‖w‖:ℝ) := by |
| by_cases hz : z=0 |
| · simp [hz] |
| by_cases hw : w=0 |
| · simp [hw] |
| have hez := complexPhase_mul_norm z |
| have hew := complexPhase_mul_norm w |
| conv_lhs => rw [←hez,←hew,←h,map_mul] |
| simp only [Complex.conj_ofReal] |
| calc |
| conj (complexPhase z)*(‖z‖:ℂ)*(complexPhase z*(‖w‖:ℂ))= |
| (complexPhase z*conj (complexPhase z))*((‖z‖:ℂ)*(‖w‖:ℂ)) := by ring |
| _ = _ := by rw [Complex.mul_conj',norm_complexPhase hz]; simp |
|
|
| lemma measurable_complexPhase : Measurable complexPhase := by unfold complexPhase; fun_prop |
|
|
| lemma IsGroundVector.ae_killed_complexPhase {N : ℕ} {L : Length} {a t : ℝ} |
| {u : Jet N L} (hu : IsGroundVector N L a u) (ht : 0≤t) : |
| ∀ᵐ ω ∂killedPathLaw N L a t, complexPhase (u.1 (ω 0))=complexPhase (u.1 (ω 1)) := by |
| have hrev := (reverse_killedPath_preserving N L a t).quasiMeasurePreserving.ae |
| (hu.ae_killed_zero_propagation ht) |
| filter_upwards [hu.ae_killed_zero_propagation ht,hu.ae_killed_endpoints_phase ht,hrev] with ω h0 hphase h1 |
| have hr : u.1 (ω 1)=0 → u.1 (ω 0)=0 := by simpa [reverseConfigurationPath] using h1 |
| by_cases hz : u.1 (ω 0)=0 |
| · rw [hz,h0 hz] |
| · exact complexPhase_eq_of_inner hz (mt hr hz) hphase |
|
|
| end HardSphere |
|
|
| namespace HardSphere |
|
|
| lemma IsGroundVector.phase_region {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L} |
| (hu : IsGroundVector N L a u) {x : Configuration N L} (hx : x∈allowed N L a) : |
| ∃z, x∈LocalAE.region volume (fun y ↦ complexPhase (u.1 y)=z) := by |
| have hm := measurable_complexPhase.comp (Lp.stronglyMeasurable u.1).measurable |
| have hpm : MeasurableSet {p : Configuration N L×Configuration N L | |
| complexPhase (u.1 p.1)=complexPhase (u.1 p.2)} := |
| measurableSet_eq_fun (hm.comp measurable_fst) (hm.comp measurable_snd) |
| obtain ⟨U,hU,hxU,hsub,hp⟩ := killed_ae_torus_local_pairs L a (P:=fun X Y ↦ complexPhase (u.1 X)=complexPhase (u.1 Y)) hpm |
| (fun t ht ↦ hu.ae_killed_complexPhase ht.le) hx |
| obtain ⟨z,hz⟩ := LocalAE.ae_local_const_of_ae_pairs volume (hU.measure_ne_zero volume ⟨x,hxU⟩) hp |
| exact ⟨z,U,hU,hxU,hz⟩ |
|
|
| def groundPhaseRepresentative {N : ℕ} {L : Length} (u : Jet N L) : Configuration N L → ℂ := |
| LocalAE.representative volume (fun y ↦ complexPhase (u.1 y)) |
|
|
| lemma IsGroundVector.ae_phaseRepresentative {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L} |
| (hu : IsGroundVector N L a u) : |
| ∀ᵐ x ∂volume.restrict (allowed N L a), complexPhase (u.1 x)=groundPhaseRepresentative u x := |
| LocalAE.representative_ae volume (isOpen_allowed N L a) (fun _ hx ↦ hu.phase_region hx) |
|
|
| lemma IsGroundVector.phaseRepresentative_eq_on_connected {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L} |
| (hu : IsGroundVector N L a u) {S : Set (Configuration N L)} (hS : IsPreconnected S) |
| (hsub : S⊆allowed N L a) {x y : Configuration N L} (hx : x∈S) (hy : y∈S) : |
| groundPhaseRepresentative u x=groundPhaseRepresentative u y := |
| LocalAE.representative_eq_on_connected volume hS (fun _ hz ↦ hu.phase_region (hsub hz)) hx hy |
|
|
| end HardSphere |
|
|
| end |
|
|
| end OAI |
|
|
