| import Mathlib |
| import OAI.Probability.ParisiFinite.OrdinaryInverseSpecial |
| import OAI.Probability.ParisiFinite.RestrictLeft |
|
|
| namespace OAI |
|
|
| /-! Inner Root Y Coordinates. -/ |
|
|
| noncomputable section |
|
|
| open scoped BigOperators ComplexConjugate InnerProductSpace Topology ComplexOrder |
| open Filter |
| open scoped BigOperators |
| open scoped Matrix Matrix.Norms.L2Operator ComplexConjugate |
| open scoped InnerProductSpace ComplexConjugate |
| open Filter Topology |
| open Filter Set Topology |
| open scoped InnerProductSpace ComplexConjugate Topology |
| open scoped InnerProductSpace |
| namespace CoherentFock |
| open PointedTree RootSpin Complex |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E] |
|
|
| |
|
|
| theorem inner_rootY_coordinates (x y : SpinSpace E) : |
| ⟪SpinOperators.act Y x,y⟫_ℂ=I*⟪x 1,y 0⟫_ℂ-I*⟪x 0,y 1⟫_ℂ := by |
| simp [PiLp.inner_apply,SpinOperators.act_apply,Fin.sum_univ_two,Y, |
| inner_smul_left,sub_eq_add_neg] |
|
|
| theorem inner_rootY_spinW_same_plus (d e : E) (x y : PreSpin E) (hx : x 1=0) (hy : y 1=0) : |
| ⟪SpinOperators.act Y (spinW d (spinCoe x)),spinW e (spinCoe y)⟫_ℂ=0 := by |
| rw [inner_rootY_coordinates] |
| simp [hx,hy] |
|
|
| theorem inner_rootY_spinW_same_minus (d e : E) (x y : PreSpin E) (hx : x 0=0) (hy : y 0=0) : |
| ⟪SpinOperators.act Y (spinW d (spinCoe x)),spinW e (spinCoe y)⟫_ℂ=0 := by |
| rw [inner_rootY_coordinates] |
| simp [hx,hy] |
|
|
| |
|
|
| def hugePacket (R : ℝ) (d e : E) (xp xm : PreSpin E) : SpinSpace E := |
| spinW (R • d) (spinCoe xp)+spinW (R • e) (spinCoe xm) |
|
|
| theorem norm_hugePacket_le (R : ℝ) (d e : E) (xp xm : PreSpin E) : |
| ‖hugePacket R d e xp xm‖≤ spinMass xp+spinMass xm := by |
| apply (norm_add_le _ _).trans |
| exact add_le_add ((norm_spinW _ _).trans_le (norm_spinCoe_le_mass _)) |
| ((norm_spinW _ _).trans_le (norm_spinCoe_le_mass _)) |
|
|
| theorem inner_rootY_hugePacket (R : ℝ) (d e : E) (xp xm yp ym : PreSpin E) |
| (hxp : xp 1=0) (hxm : xm 0=0) (hyp : yp 1=0) (hym : ym 0=0) : |
| ⟪SpinOperators.act Y (hugePacket R d e xp xm),hugePacket R d e yp ym⟫_ℂ= |
| ⟪SpinOperators.act Y (spinW (R • d) (spinCoe xp)),spinW (R • e) (spinCoe ym)⟫_ℂ+ |
| ⟪SpinOperators.act Y (spinW (R • e) (spinCoe xm)),spinW (R • d) (spinCoe yp)⟫_ℂ := by |
| simp only [hugePacket,map_add,inner_add_left,inner_add_right, |
| inner_rootY_spinW_same_plus _ _ _ _ hxp hyp,inner_rootY_spinW_same_minus _ _ _ _ hxm hym, |
| zero_add,add_zero] |
| exact add_comm _ _ |
|
|
| |
|
|
| theorem tendsto_inner_rootY_hugePacket {α : Type*} {l : Filter α} |
| (R : α → ℝ) (d e : α → E) (xp xm yp ym : α → PreSpin E) |
| (hR : Tendsto R l atTop) (B A δ : ℝ) (hA : 0≤ A) (hδ : 0<δ) |
| (hxp : ∀ᶠ a in l, SpinRadiusLE (xp a) B ∧ spinMass (xp a)≤ A) |
| (hxm : ∀ᶠ a in l, SpinRadiusLE (xm a) B ∧ spinMass (xm a)≤ A) |
| (hyp : ∀ᶠ a in l, SpinRadiusLE (yp a) B ∧ spinMass (yp a)≤ A) |
| (hym : ∀ᶠ a in l, SpinRadiusLE (ym a) B ∧ spinMass (ym a)≤ A) |
| (hs : ∀ᶠ a in l, xp a 1=0 ∧ xm a 0=0 ∧ yp a 1=0 ∧ ym a 0=0) |
| (hsep : ∀ᶠ a in l, δ≤ ‖d a-e a‖) : |
| Tendsto (fun a => ⟪SpinOperators.act Y (hugePacket (R a) (d a) (e a) (xp a) (xm a)), |
| hugePacket (R a) (d a) (e a) (yp a) (ym a)⟫_ℂ) l (𝓝 0) := by |
| have hP : ∀ᶠ a : α in l, matrixMass Y≤ matrixMass Y := Filter.Eventually.of_forall (fun _ => le_rfl) |
| have h1 := rapid_decay_spin_matrix R d e xp ym (fun _ => Y) hR B A (matrixMass Y) δ hA |
| (matrixMass_nonneg _) hδ hxp hym hP hsep 0 |
| have hsep' : ∀ᶠ a in l, δ≤ ‖e a-d a‖ := hsep.mono (fun a ha => by rwa [norm_sub_rev]) |
| have h2 := rapid_decay_spin_matrix R e d xm yp (fun _ => Y) hR B A (matrixMass Y) δ hA |
| (matrixMass_nonneg _) hδ hxm hyp hP hsep' 0 |
| simp only [pow_zero,one_mul] at h1 h2 |
| have h1' := tendsto_zero_iff_norm_tendsto_zero.mpr h1 |
| have h2' := tendsto_zero_iff_norm_tendsto_zero.mpr h2 |
| have hh := h1'.add h2' |
| simp only [add_zero] at hh |
| apply hh.congr' |
| filter_upwards [hs] with a ha |
| exact (inner_rootY_hugePacket (R a) (d a) (e a) (xp a) (xm a) (yp a) (ym a) |
| ha.1 ha.2.1 ha.2.2.1 ha.2.2.2).symm |
|
|
| |
|
|
| theorem inner_rootY_error_bound (x y u v : SpinSpace E) : |
| ‖⟪SpinOperators.act Y x,y⟫_ℂ-⟪SpinOperators.act Y u,v⟫_ℂ‖≤ |
| ‖x-u‖*‖y‖+‖u‖*‖y-v‖ := by |
| have hY (w : SpinSpace E) : ‖SpinOperators.act Y w‖=‖w‖ := |
| (SpinOperators.actEquiv Y Y_unitary).norm_map w |
| have he : ⟪SpinOperators.act Y x,y⟫_ℂ-⟪SpinOperators.act Y u,v⟫_ℂ= |
| ⟪SpinOperators.act Y (x-u),y⟫_ℂ+⟪SpinOperators.act Y u,y-v⟫_ℂ := by |
| simp only [map_sub,inner_sub_left,inner_sub_right] |
| ring |
| rw [he] |
| apply (norm_add_le _ _).trans |
| simpa only [hY] using add_le_add (norm_inner_le_norm (𝕜 := ℂ) (SpinOperators.act Y (x-u)) y) |
| (norm_inner_le_norm (𝕜 := ℂ) (SpinOperators.act Y u) (y-v)) |
|
|
| |
|
|
| theorem huge_transverse_actual {α : Type*} {l : Filter α} |
| (U : α → SpinSpace E ≃ₗᵢ[ℂ] SpinSpace E) (Ω : SpinSpace E) (η : α → SpinSpace E) |
| (R : α → ℝ) (d e : α → E) (xp xm yp ym : α → PreSpin E) |
| (hR : Tendsto R l atTop) (B A δ C : ℝ) (hA : 0≤ A) (hδ : 0<δ) |
| (hxp : ∀ᶠ a in l, SpinRadiusLE (xp a) B ∧ spinMass (xp a)≤ A) |
| (hxm : ∀ᶠ a in l, SpinRadiusLE (xm a) B ∧ spinMass (xm a)≤ A) |
| (hyp : ∀ᶠ a in l, SpinRadiusLE (yp a) B ∧ spinMass (yp a)≤ A) |
| (hym : ∀ᶠ a in l, SpinRadiusLE (ym a) B ∧ spinMass (ym a)≤ A) |
| (hs : ∀ᶠ a in l, xp a 1=0 ∧ xm a 0=0 ∧ yp a 1=0 ∧ ym a 0=0) |
| (hsep : ∀ᶠ a in l, δ≤ ‖d a-e a‖) (hη : ∀ᶠ a in l, ‖η a‖≤ C) |
| (herrΩ : Tendsto (fun a => ‖U a Ω-hugePacket (R a) (d a) (e a) (xp a) (xm a)‖) l (𝓝 0)) |
| (herrη : Tendsto (fun a => ‖U a (η a)-hugePacket (R a) (d a) (e a) (yp a) (ym a)‖) l (𝓝 0)) : |
| Tendsto (fun a => ⟪(U a).symm (SpinOperators.act Y (U a Ω)),η a⟫_ℂ) l (𝓝 0) := by |
| let P a := hugePacket (R a) (d a) (e a) (xp a) (xm a) |
| let Q a := hugePacket (R a) (d a) (e a) (yp a) (ym a) |
| have hp := tendsto_inner_rootY_hugePacket R d e xp xm yp ym hR B A δ hA hδ hxp hxm hyp hym hs hsep |
| have he : Tendsto (fun a => |
| ⟪SpinOperators.act Y (U a Ω),U a (η a)⟫_ℂ-⟪SpinOperators.act Y (P a),Q a⟫_ℂ) l (𝓝 0) := by |
| rw [tendsto_zero_iff_norm_tendsto_zero] |
| have hb := (herrΩ.mul_const C).add (herrη.const_mul (2*A)) |
| simp only [zero_mul,mul_zero,add_zero] at hb |
| apply squeeze_zero' (Filter.Eventually.of_forall (fun _ => norm_nonneg _)) _ hb |
| filter_upwards [hxp,hxm,hη] with a hpa hma hηa |
| apply (inner_rootY_error_bound (U a Ω) (U a (η a)) (P a) (Q a)).trans |
| have hpn : ‖P a‖≤ 2*A := (norm_hugePacket_le _ _ _ _ _).trans (by linarith [hpa.2,hma.2]) |
| rw [(U a).norm_map] |
| exact add_le_add (mul_le_mul_of_nonneg_left hηa (norm_nonneg _)) |
| (mul_le_mul_of_nonneg_right hpn (norm_nonneg _)) |
| have hh := he.add hp |
| simp only [P,Q,sub_add_cancel,add_zero] at hh |
| convert hh using 1 |
| ext a |
| have hv := (U a).inner_map_map ((U a).symm (SpinOperators.act Y (U a Ω))) (η a) |
| simpa only [LinearIsometryEquiv.apply_symm_apply] using hv.symm |
|
|
| end CoherentFock |
|
|
| namespace GaussianCoherent |
| open MeasureTheory ProbabilityTheory Complex CoherentFock |
| open scoped BigOperators InnerProductSpace ComplexConjugate |
| variable {κ : Type*} [Fintype κ] |
|
|
| abbrev Mode (κ : Type*) [Fintype κ] := EuclideanSpace ℂ κ |
| abbrev Hilbert (κ : Type*) [Fintype κ] := Lp ℂ 2 (GaussianFourier.law κ) |
|
|
| |
|
|
| def offset (d : Mode κ) : ℂ := (∑k, (d k)^2)/2-((‖d‖^2:ℝ):ℂ)/2 |
|
|
| def wave (d : Mode κ) (g : κ → ℝ) : ℂ := |
| Complex.exp (offset d)*Complex.exp (∑k, I*d k*(g k:ℂ)) |
|
|
| theorem continuous_wave (d : Mode κ) : Continuous (wave d) := by |
| unfold wave |
| fun_prop |
|
|
| theorem wave_pair (d e : Mode κ) (g : κ → ℝ) : |
| conj (wave d g)*wave e g= |
| Complex.exp (conj (offset d)+offset e)* |
| Complex.exp (∑k, (I*(e k-conj (d k)))*(g k:ℂ)) := by |
| simp only [wave,map_mul,←Complex.exp_conj,map_sum,Complex.conj_I,Complex.conj_ofReal] |
| rw [←Complex.exp_add,←Complex.exp_add,←Complex.exp_add,←Complex.exp_add] |
| congr 1 |
| have hh : (∑k, -I*conj (d k)*(g k:ℂ))+(∑k, I*e k*(g k:ℂ))= |
| ∑k, I*(e k-conj (d k))*(g k:ℂ) := by |
| rw [←Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro k hk |
| ring |
| linear_combination hh |
|
|
| theorem integrable_wave_pair (d e : Mode κ) : |
| Integrable (fun g => conj (wave d g)*wave e g) (GaussianFourier.law κ) := by |
| simp_rw [wave_pair] |
| exact (GaussianFourier.integrable_exp_sum (fun k => I*(e k-conj (d k)))).const_mul _ |
|
|
| theorem exponent_pair (d e : Mode κ) : |
| conj (offset d)+offset e+(∑k, (I*(e k-conj (d k)))^2/2)= |
| -((‖d‖^2+‖e‖^2:ℝ):ℂ)/2+⟪d,e⟫_ℂ := by |
| simp only [offset,map_sub,map_div₀,map_sum,map_pow,Complex.conj_ofReal, |
| map_ofNat,PiLp.inner_apply,RCLike.inner_apply'] |
| push_cast |
| simp_rw [←Finset.sum_div] |
| have hs : (∑k, (conj (d k))^2)+(∑k, (e k)^2)+ |
| (∑k, (I*(e k-conj (d k)))^2)=2*∑k, conj (d k)*e k := by |
| rw [←Finset.sum_add_distrib,←Finset.sum_add_distrib,Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro k hk |
| ring_nf |
| rw [Complex.I_sq] |
| ring |
| linear_combination hs/2 |
|
|
| |
|
|
| theorem integral_wave_pair (d e : Mode κ) : |
| (∫g, conj (wave d g)*wave e g ∂GaussianFourier.law κ)=kernel d e := by |
| simp_rw [wave_pair] |
| rw [integral_const_mul,GaussianFourier.integral_exp_sum,←Complex.exp_add,exponent_pair] |
| unfold kernel |
| congr 1 |
| push_cast |
| ring |
|
|
| theorem memLp_wave (d : Mode κ) : MemLp (wave d) 2 (GaussianFourier.law κ) := by |
| apply (memLp_two_iff_integrable_sq_norm (continuous_wave d).aestronglyMeasurable).mpr |
| have h := (integrable_wave_pair d d).re |
| convert h using 1 |
| funext g |
| rw [Complex.conj_mul'] |
| change ‖wave d g‖^2 = ((‖wave d g‖:ℂ)^2).re |
| rw [←Complex.ofReal_pow,Complex.ofReal_re] |
|
|
| def vector (d : Mode κ) : Hilbert κ := (memLp_wave d).toLp (wave d) |
|
|
| theorem vector_ae (d : Mode κ) : (vector d : (κ → ℝ) → ℂ)=ᵐ[GaussianFourier.law κ] wave d := |
| (memLp_wave d).coeFn_toLp |
|
|
| @[simp] theorem inner_vector (d e : Mode κ) : ⟪vector d,vector e⟫_ℂ=kernel d e := by |
| rw [L2.inner_def] |
| rw [←integral_wave_pair d e] |
| apply integral_congr_ae |
| filter_upwards [vector_ae d,vector_ae e] with g hd he |
| rw [hd,he] |
| exact RCLike.inner_apply' _ _ |
|
|
| |
|
|
| def preMap : PreSpace (Mode κ) →ₗᵢ[ℂ] Hilbert κ := |
| LinearMap.isometryOfInner |
| ((Finsupp.linearCombination ℂ vector).comp toFinsupp.toLinearMap) (by |
| intro x y |
| change ⟪(toFinsupp x).sum (fun d a => a • vector d), |
| (toFinsupp y).sum (fun e b => b • vector e)⟫_ℂ=_ |
| rw [Finsupp.sum_inner] |
| change (toFinsupp x).sum (fun d a => ⟪a • vector d, |
| (toFinsupp y).sum (fun e b => b • vector e)⟫_ℂ)= |
| (toFinsupp x).sum (fun d a => (toFinsupp y).sum (fun e b => conj a*kernel d e*b)) |
| apply Finsupp.sum_congr |
| intro d hd |
| rw [Finsupp.inner_sum] |
| apply Finsupp.sum_congr |
| intro e he |
| simp only [inner_smul_left,inner_smul_right,inner_vector] |
| ring) |
|
|
| |
| def representation : Space (Mode κ) →ₗᵢ[ℂ] Hilbert κ where |
| toLinearMap := preMap.toContinuousLinearMap.fromCompletion.toLinearMap |
| norm_map' x := by |
| refine UniformSpace.Completion.induction_on x |
| (isClosed_eq (preMap.toContinuousLinearMap.fromCompletion.continuous.norm) continuous_norm) |
| fun y => ?_ |
| change ‖preMap.toContinuousLinearMap.fromCompletion (y:Space (Mode κ))‖=‖(y:Space (Mode κ))‖ |
| rw [ContinuousLinearMap.fromCompletion_apply_coe,UniformSpace.Completion.norm_coe] |
| exact preMap.norm_map y |
|
|
| @[simp] theorem representation_coherent (d : Mode κ) : representation (coherent d)=vector d := by |
| change preMap.toContinuousLinearMap.fromCompletion |
| ((toFinsupp.symm (Finsupp.single d 1):PreSpace (Mode κ)):Space (Mode κ))=vector d |
| rw [ContinuousLinearMap.fromCompletion_apply_coe] |
| change Finsupp.linearCombination ℂ vector (Finsupp.single d 1)=vector d |
| simp |
|
|
| end GaussianCoherent |
|
|
| namespace GaussianCoherent |
| open MeasureTheory ProbabilityTheory Complex CoherentFock |
| open scoped BigOperators InnerProductSpace ComplexConjugate |
| variable {κ : Type*} [Fintype κ] |
|
|
| def realMode (a : κ → ℝ) : Mode κ := WithLp.toLp 2 (fun k => (a k:ℂ)) |
|
|
| @[simp] theorem realMode_apply (a : κ → ℝ) (k : κ) : realMode a k=(a k:ℂ) := rfl |
|
|
| @[simp] theorem norm_realMode_sq (a : κ → ℝ) : ‖realMode a‖^2=∑k, (a k)^2 := by |
| rw [EuclideanSpace.norm_sq_eq] |
| simp [Real.norm_eq_abs,sq_abs] |
|
|
| @[simp] theorem offset_realMode (a : κ → ℝ) : offset (realMode a)=0 := by |
| simp [offset,norm_realMode_sq,Complex.ofReal_sum] |
|
|
| @[simp] theorem wave_realMode (a : κ → ℝ) (g : κ → ℝ) : |
| wave (realMode a) g=Complex.exp ((∑k, a k*g k:ℝ)*I) := by |
| simp only [wave,offset_realMode,Complex.exp_zero,one_mul,realMode_apply] |
| congr 1 |
| push_cast |
| rw [Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro k hk |
| ring |
|
|
| @[simp] theorem norm_wave_realMode (a : κ → ℝ) (g : κ → ℝ) : ‖wave (realMode a) g‖=1 := by |
| rw [wave_realMode,Complex.norm_exp] |
| simp |
|
|
| theorem memLp_seedPhase (a : κ → ℝ) (f : Hilbert κ) : |
| MemLp (fun g => wave (realMode a) g*f g) 2 (GaussianFourier.law κ) := by |
| apply (Lp.memLp f).congr_norm |
| ((continuous_wave (realMode a)).aestronglyMeasurable.mul (Lp.aestronglyMeasurable f)) |
| exact Filter.Eventually.of_forall fun g => by |
| change ‖f g‖=‖wave (realMode a) g*f g‖ |
| rw [norm_mul,norm_wave_realMode,one_mul] |
|
|
| |
| def seedPhase (a : κ → ℝ) (f : Hilbert κ) : Hilbert κ := |
| (memLp_seedPhase a f).toLp (fun g => wave (realMode a) g*f g) |
|
|
| theorem seedPhase_ae (a : κ → ℝ) (f : Hilbert κ) : |
| (seedPhase a f : (κ → ℝ) → ℂ)=ᵐ[GaussianFourier.law κ] fun g => wave (realMode a) g*f g := |
| MemLp.coeFn_toLp _ |
|
|
| |
|
|
| def seedPhaseIsometry (a : κ → ℝ) : Hilbert κ →ₗᵢ[ℂ] Hilbert κ where |
| toFun := seedPhase a |
| map_add' f h := by |
| apply Lp.ext |
| filter_upwards [seedPhase_ae a (f+h),Lp.coeFn_add f h, |
| Lp.coeFn_add (seedPhase a f) (seedPhase a h),seedPhase_ae a f,seedPhase_ae a h] with g h1 h2 h3 h4 h5 |
| rw [h1,h2,h3] |
| simp only [Pi.add_apply,h4,h5] |
| exact mul_add _ _ _ |
| map_smul' c f := by |
| change seedPhase a (c • f)=c • seedPhase a f |
| apply Lp.ext |
| filter_upwards [seedPhase_ae a (c • f),Lp.coeFn_smul c f, |
| Lp.coeFn_smul c (seedPhase a f),seedPhase_ae a f] with g h1 h2 h3 h4 |
| rw [h1,h2,h3] |
| simp only [Pi.smul_apply,h4] |
| simp only [smul_eq_mul] |
| ring |
| norm_map' f := by |
| have hh : ∀ᵐ g ∂GaussianFourier.law κ, ‖seedPhase a f g‖=‖f g‖ := by |
| filter_upwards [seedPhase_ae a f] with g hg |
| rw [hg,norm_mul,norm_wave_realMode,one_mul] |
| exact le_antisymm (Lp.norm_le_norm_of_ae_le (hh.mono fun _ h => h.le)) |
| (Lp.norm_le_norm_of_ae_le (hh.mono fun _ h => h.ge)) |
|
|
| theorem offset_real_add (a : κ → ℝ) (d : Mode κ) : |
| offset (realMode a+d)=offset d+((⟪realMode a,d⟫_ℂ).im:ℂ)*I := by |
| have hs : (∑k, (realMode a k+d k)^2)= |
| (∑k, (realMode a k)^2)+2*⟪realMode a,d⟫_ℂ+(∑k, (d k)^2) := by |
| simp only [PiLp.inner_apply,RCLike.inner_apply',realMode_apply,Complex.conj_ofReal] |
| rw [Finset.mul_sum,←Finset.sum_add_distrib,←Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro k hk |
| ring |
| have ho := offset_realMode a |
| unfold offset at ho ⊢ |
| simp only [PiLp.add_apply] |
| rw [_root_.norm_add_sq (𝕜 := ℂ)] |
| rw [hs] |
| have hc := Complex.re_add_im ⟪realMode a,d⟫_ℂ |
| push_cast at ho ⊢ |
| linear_combination ho - hc |
|
|
| |
|
|
| theorem phase_wave_real_add (a : κ → ℝ) (d : Mode κ) (g : κ → ℝ) : |
| phase (realMode a) d*wave (realMode a+d) g=wave (realMode a) g*wave d g := by |
| simp only [phase,wave,offset_realMode,Complex.exp_zero,one_mul,offset_real_add] |
| simp only [←Complex.exp_add] |
| congr 1 |
| simp only [PiLp.add_apply,mul_add,add_mul,Finset.sum_add_distrib] |
| push_cast |
| ring |
|
|
| theorem seedPhase_vector (a : κ → ℝ) (d : Mode κ) : |
| seedPhaseIsometry a (vector d)=phase (realMode a) d • vector (realMode a+d) := by |
| apply Lp.ext |
| filter_upwards [seedPhase_ae a (vector d),vector_ae d,vector_ae (realMode a+d), |
| Lp.coeFn_smul (phase (realMode a) d) (vector (realMode a+d))] with g h1 h2 h3 h4 |
| change seedPhase a (vector d) g = _ |
| rw [h1,h2,h4] |
| simp only [Pi.smul_apply,smul_eq_mul] |
| rw [h3] |
| exact (phase_wave_real_add a d g).symm |
|
|
| |
| theorem representation_W_real (a : κ → ℝ) (x : Space (Mode κ)) : |
| representation (W (realMode a) x)=seedPhaseIsometry a (representation x) := by |
| have he : representation.toContinuousLinearMap.comp (W (realMode a))= |
| (seedPhaseIsometry a).toContinuousLinearMap.comp representation.toContinuousLinearMap := by |
| apply CoherentFock.ext_coherent |
| intro d |
| simp only [ContinuousLinearMap.comp_apply,LinearIsometry.coe_toContinuousLinearMap, |
| W_coherent,map_smul,representation_coherent,seedPhase_vector] |
| exact DFunLike.congr_fun he x |
|
|
| end GaussianCoherent |
| namespace FourierDensity |
| open MeasureTheory ProbabilityTheory Complex |
| open scoped BigOperators ComplexConjugate InnerProductSpace |
| variable {κ : Type*} [Fintype κ] |
|
|
| def character (a g : κ → ℝ) : ℂ := Complex.exp ((∑k, a k*g k:ℝ)*I) |
|
|
| theorem continuous_character (a : κ → ℝ) : Continuous (character a) := by |
| unfold character |
| fun_prop |
|
|
| @[simp] theorem norm_character (a g : κ → ℝ) : ‖character a g‖=1 := by |
| simp [character,Complex.norm_exp] |
|
|
| @[simp] theorem character_neg (a g : κ → ℝ) : character (-a) g=conj (character a g) := by |
| simp [character,←Complex.exp_conj,Finset.sum_neg_distrib] |
|
|
| variable {μ : Measure (κ → ℝ)} |
|
|
| theorem integrable_character_mul {f : (κ → ℝ) → ℂ} |
| (hf : Integrable f μ) (a : κ → ℝ) : Integrable (fun g => character a g*f g) μ := |
| hf.bdd_mul (continuous_character a).aestronglyMeasurable |
| (Filter.Eventually.of_forall fun g => (norm_character a g).le) |
|
|
| theorem dual_eq_sum [DecidableEq κ] (L : StrongDual ℝ (κ → ℝ)) (g : κ → ℝ) : |
| L g=∑k, L (Pi.single k 1)*g k := by |
| classical |
| have hg : g=∑k, g k • Pi.single k 1 := by |
| ext j |
| simp [Finset.sum_apply,Pi.smul_apply,Pi.single_apply] |
| conv_lhs => rw [hg] |
| simp only [map_sum,map_smul,smul_eq_mul,mul_comm] |
|
|
| |
|
|
| theorem ae_zero_of_real_fourier_zero [IsFiniteMeasure μ] |
| {f : (κ → ℝ) → ℝ} (hf : Integrable f μ) |
| (hF : ∀a, (∫g, character a g*(f g:ℂ) ∂μ)=0) : f=ᵐ[μ] 0 := by |
| classical |
| let fpos := fun g => max (f g) 0 |
| let fneg := fun g => max (-f g) 0 |
| have hp : Integrable fpos μ := hf.pos_part |
| have hn : Integrable fneg μ := hf.neg_part |
| let μp := μ.withDensity (fun g => ENNReal.ofReal (fpos g)) |
| let μn := μ.withDensity (fun g => ENNReal.ofReal (fneg g)) |
| have : IsFiniteMeasure μp := isFiniteMeasure_withDensity_ofReal hp.2 |
| have : IsFiniteMeasure μn := isFiniteMeasure_withDensity_ofReal hn.2 |
| have heq : μp=μn := by |
| apply Measure.ext_of_charFunDual |
| funext L |
| simp only [charFunDual_apply] |
| have hl : (fun g => Complex.exp ((L g : ℝ)*I))= |
| character (fun k => L (Pi.single k 1)) := by |
| funext g |
| rw [dual_eq_sum L g] |
| rfl |
| rw [hl] |
| change (∫g, character (fun k => L (Pi.single k 1)) g ∂μp)= |
| (∫g, character (fun k => L (Pi.single k 1)) g ∂μn) |
| dsimp only [μp,μn] |
| rw [integral_withDensity_eq_integral_toReal_smul₀ hp.1.aemeasurable.ennreal_ofReal |
| (Filter.Eventually.of_forall fun _ => ENNReal.ofReal_lt_top), |
| integral_withDensity_eq_integral_toReal_smul₀ hn.1.aemeasurable.ennreal_ofReal |
| (Filter.Eventually.of_forall fun _ => ENNReal.ofReal_lt_top)] |
| simp only [ENNReal.toReal_ofReal (le_max_right _ _),fpos,fneg,real_smul] |
| apply sub_eq_zero.mp |
| change (∫g, (fpos g:ℂ)*character (fun k => L (Pi.single k 1)) g ∂μ)- |
| (∫g, (fneg g:ℂ)*character (fun k => L (Pi.single k 1)) g ∂μ)=0 |
| have hpC : Integrable (fun g => (fpos g:ℂ)*character |
| (fun k => L (Pi.single k 1)) g) μ := |
| (integrable_character_mul hp.ofReal (fun k => L (Pi.single k 1))).congr |
| (Filter.Eventually.of_forall fun g => mul_comm _ _) |
| have hnC : Integrable (fun g => (fneg g:ℂ)*character |
| (fun k => L (Pi.single k 1)) g) μ := |
| (integrable_character_mul hn.ofReal (fun k => L (Pi.single k 1))).congr |
| (Filter.Eventually.of_forall fun g => mul_comm _ _) |
| rw [←integral_sub hpC hnC] |
| convert hF (fun k => L (Pi.single k 1)) using 1 |
| congr 1 |
| funext g |
| have hm : max (f g) 0-max (-f g) 0=f g := max_zero_sub_max_neg_zero_eq_self _ |
| dsimp only [fpos,fneg] |
| rw [←sub_mul,←Complex.ofReal_sub,hm,mul_comm] |
| have hd := (withDensity_eq_iff_of_sigmaFinite hp.1.aemeasurable.ennreal_ofReal |
| hn.1.aemeasurable.ennreal_ofReal).mp heq |
| filter_upwards [hd] with g hg |
| have hh := congrArg ENNReal.toReal hg |
| simp only [ENNReal.toReal_ofReal (le_max_right _ _),fpos,fneg] at hh |
| change f g=0 |
| have hm : max (f g) 0-max (-f g) 0=f g := max_zero_sub_max_neg_zero_eq_self _ |
| linarith |
|
|
| |
| theorem ae_re_zero_of_fourier_zero [IsFiniteMeasure μ] |
| {f : (κ → ℝ) → ℂ} (hf : Integrable f μ) |
| (hF : ∀a, (∫g, character a g*f g ∂μ)=0) : |
| (fun g => (f g).re)=ᵐ[μ] 0 := by |
| have hc : ∀a, (∫g, character a g*conj (f g) ∂μ)=0 := by |
| intro a |
| have hh := congrArg conj (hF (-a)) |
| rw [map_zero,←integral_conj] at hh |
| simpa only [map_mul,character_neg,Complex.conj_conj] using hh |
| have hfc : Integrable (fun g => conj (f g)) μ := |
| (@RCLike.conjLIE ℂ _).toContinuousLinearEquiv.toContinuousLinearMap.integrable_comp hf |
| apply ae_zero_of_real_fourier_zero hf.re |
| intro a |
| calc |
| (∫g, character a g*((f g).re:ℂ) ∂μ)= |
| (1/2:ℂ)*(∫g, character a g*f g+character a g*conj (f g) ∂μ) := by |
| rw [←integral_const_mul] |
| apply integral_congr_ae |
| exact Filter.Eventually.of_forall fun g => by |
| have hadd := Complex.add_conj (f g) |
| push_cast at hadd |
| linear_combination -(character a g)*hadd/2 |
| _=0 := by |
| rw [integral_add (integrable_character_mul hf a) (integrable_character_mul hfc a), |
| hF a,hc a] |
| simp |
|
|
| |
|
|
| theorem ae_zero_of_fourier_zero [IsFiniteMeasure μ] |
| {f : (κ → ℝ) → ℂ} (hf : Integrable f μ) |
| (hF : ∀a, (∫g, character a g*f g ∂μ)=0) : f=ᵐ[μ] 0 := by |
| have hr := ae_re_zero_of_fourier_zero hf hF |
| have hi := ae_re_zero_of_fourier_zero (hf.const_mul I) (fun a => by |
| calc |
| (∫g, character a g*(I*f g) ∂μ)=I*(∫g, character a g*f g ∂μ) := by |
| rw [←integral_const_mul] |
| congr 1 |
| funext g |
| ring |
| _=0 := by rw [hF a,mul_zero]) |
| filter_upwards [hr,hi] with g hrg hig |
| apply Complex.ext |
| · exact hrg |
| · simpa using hig |
|
|
| end FourierDensity |
|
|
| namespace GaussianCoherent |
| open MeasureTheory ProbabilityTheory Complex CoherentFock |
| open scoped BigOperators InnerProductSpace ComplexConjugate |
| variable {κ : Type*} [Fintype κ] |
|
|
| |
|
|
| theorem representation_surjective : Function.Surjective (representation (κ := κ)) := by |
| let K := (representation (κ := κ)).toLinearMap.range |
| have hK : IsClosed (K : Set (Hilbert κ)) := |
| (representation (κ := κ)).isometry.isClosedEmbedding.isClosed_range |
| have hbot : Kᗮ=⊥ := by |
| apply (Submodule.eq_bot_iff _).mpr |
| intro f hf |
| apply Lp.ext |
| have hi : Integrable (fun g => f g) (GaussianFourier.law κ) := |
| memLp_one_iff_integrable.mp ((Lp.memLp f).mono_exponent (by norm_num)) |
| have hF : ∀a, (∫g, FourierDensity.character a g*f g ∂GaussianFourier.law κ)=0 := by |
| intro a |
| have hh := (Submodule.mem_orthogonal K f).mp hf (vector (realMode (-a))) |
| ⟨coherent (realMode (-a)),representation_coherent _⟩ |
| rw [L2.inner_def] at hh |
| convert hh using 1 |
| apply integral_congr_ae |
| filter_upwards [vector_ae (realMode (-a))] with g hg |
| rw [RCLike.inner_apply',hg,wave_realMode] |
| change FourierDensity.character a g*f g= |
| conj (FourierDensity.character (-a) g)*f g |
| rw [FourierDensity.character_neg,Complex.conj_conj] |
| have hz := FourierDensity.ae_zero_of_fourier_zero hi hF |
| exact hz.trans (Lp.coeFn_zero ℂ 2 (GaussianFourier.law κ)).symm |
| apply LinearMap.range_eq_top.mp |
| change K=⊤ |
| calc |
| K=K.topologicalClosure := hK.submodule_topologicalClosure_eq.symm |
| _=Kᗮᗮ := (Submodule.orthogonal_orthogonal_eq_closure K).symm |
| _=⊤ := by rw [hbot,Submodule.bot_orthogonal_eq_top] |
|
|
| |
| def gaussianUnitary : Space (Mode κ) ≃ₗᵢ[ℂ] Hilbert κ := |
| LinearIsometryEquiv.ofSurjective representation representation_surjective |
|
|
| @[simp] theorem gaussianUnitary_coherent (d : Mode κ) : |
| gaussianUnitary (coherent d)=vector d := representation_coherent d |
|
|
| theorem gaussianUnitary_W_real (a : κ → ℝ) (x : Space (Mode κ)) : |
| gaussianUnitary (W (realMode a) x)=seedPhaseIsometry a (gaussianUnitary x) := |
| representation_W_real a x |
|
|
| end GaussianCoherent |
|
|
| namespace CoherentFock |
| open scoped InnerProductSpace ComplexConjugate |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E] |
|
|
| theorem eq_zero_of_inner_coherent (x : Space E) (hx : ∀d, ⟪coherent d,x⟫_ℂ=0) : x=0 := by |
| have hh : innerSL ℂ x=0 := by |
| apply ext_coherent |
| intro d |
| exact inner_eq_zero_symm.mp (hx d) |
| have hhx := DFunLike.congr_fun hh x |
| exact inner_self_eq_zero.mp hhx |
| end CoherentFock |
|
|
| end |
|
|
| end OAI |
|
|
