| import Mathlib |
| import OAI.Probability.LogConcave.Sampling.ConditionalFieldMean |
| import OAI.Probability.LogConcave.JetEstimates.Extension |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open MeasureTheory Filter |
| open scoped ENNReal NNReal Topology |
|
|
| section UpperProof |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal RealInnerProductSpace Topology |
| open Function MeasureTheory Set Filter |
| open scoped Topology NNReal |
|
|
| namespace LogConcaveSampling |
| open MeasureTheory |
| open scoped RealInnerProductSpace |
|
|
| def conditionalSlotEmbedding {ι : Type*} (d : ℕ) (s : ι → Bool) : |
| (ι → Fin d) ↪ (ι → Fin d ⊕ Fin d) where |
| toFun a i := if s i then Sum.inr (a i) else Sum.inl (a i) |
| inj' := by |
| intro a c h |
| funext i |
| have hi := congrFun h i |
| cases hs : s i <;> simpa [hs] using hi |
|
|
| theorem conditional_cumulant_energy {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r) |
| (hlam : 0<lam) (hl : (lam:ℝ)*r^2 ≤ 1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) (y : Point d) |
| {ι ϑ : Type*} [Fintype ι] [DecidableEq ι] [Fintype ϑ] [DecidableEq ϑ] |
| (s : ι → Bool) (t : ϑ → Bool) (l : List ι) (k : List ϑ) |
| (hlN : l.Nodup) (hlall : l.toFinset=Finset.univ) |
| (hkN : k.Nodup) (hkall : k.toFinset=Finset.univ) (hlne : l≠[]) (hkne : k≠[]) : |
| let μ := jointConditionalLaw F x r ρ y ((lam:ℝ)*r) |
| let b := EuclideanSpace.basisFun (Fin d ⊕ Fin d) ℝ |
| TensorEnergy.Bound (fun (a : ι → Fin d) (c : ϑ → Fin d) => |
| JetCalculus.mixedJet (fun i => b (conditionalSlotEmbedding d s a i)) |
| (fun j => b (conditionalSlotEmbedding d t c j)) l k |
| (fun z => Real.log (Appell.laplace μ (fun _ => (1:ℝ)) (z.1+z.2)))) |
| (((Fintype.card ι+Fintype.card ϑ+1:ℕ):ℝ)^(2*(Fintype.card ι+Fintype.card ϑ+1)) * |
| Appell.splitConstant (2*Real.pi^2*(1-ρ^2)) (Fintype.card ι) (Fintype.card ϑ)) := by |
| obtain ⟨hp,hm,hP⟩ := jointConditionalLaw_properties hF x hr hlam hl hρ0 hρ1 y |
| let := hp |
| have hβ : 0 ≤ 2*Real.pi^2*(1-ρ^2) := by |
| obtain ⟨ha,_⟩ := probability_time hρ0 hρ1 |
| positivity |
| exact (Appell.actual_cumulant_energy hm hβ hP |
| (EuclideanSpace.basisFun (Fin d ⊕ Fin d) ℝ) l k hlN hlall hkN hkall hlne hkne).submatrix |
| (conditionalSlotEmbedding d s) (conditionalSlotEmbedding d t) |
|
|
| end LogConcaveSampling |
|
|
| namespace LogConcaveSampling |
| open MeasureTheory |
| open scoped RealInnerProductSpace |
|
|
| def conditionalU {d : ℕ} (F : Point d → ℝ) (x : Point d) (r ρ : ℝ) |
| (y u : Point d) (L : ℝ) {ι : Type*} (v : ι → Point d) (l : List ι) : ℝ := |
| L/(1-ρ^2)^l.length * JetCalculus.jet (fun i => jointPosition d (v i)) l |
| (JetCalculus.dir (jointField d u) |
| (fun θ => Real.log (Appell.laplace (jointConditionalLaw F x r ρ y L) |
| (fun _ => (1:ℝ)) θ))) 0 |
|
|
| lemma conditionalFieldMean_jet_U {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r) |
| (hlam : 0<lam) (hl : (lam:ℝ)*r^2≤1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) |
| (u y : Point d) {ι : Type*} (v : ι → Point d) (l : List ι) : |
| JetCalculus.jet v l |
| (conditionalMeanScalar F x r ρ (fun z => inner ℝ u (primitiveField F x r z))) y= |
| ρ^l.length*conditionalU F x r ρ y u ((lam:ℝ)*r) v l := by |
| rw [conditionalFieldMean_jet hF x hr hlam hl hρ0 hρ1 u y v l] |
| simp only [conditionalU,div_pow] |
| ring |
|
|
| theorem conditional_jet_cumulant_energy {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r) |
| (hlam : 0<lam) (hl : (lam:ℝ)*r^2 ≤ 1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) (y : Point d) |
| {ι ϑ : Type*} [Fintype ι] [DecidableEq ι] [Fintype ϑ] [DecidableEq ϑ] |
| (s : ι → Bool) (t : ϑ → Bool) (l : List ι) (k : List ϑ) |
| (hlN : l.Nodup) (hlall : l.toFinset=Finset.univ) |
| (hkN : k.Nodup) (hkall : k.toFinset=Finset.univ) (hlne : l≠[]) (hkne : k≠[]) |
| (o : List (ι ⊕ ϑ)) (ho : o.Perm (l.map Sum.inl++k.map Sum.inr)) : |
| let μ := jointConditionalLaw F x r ρ y ((lam:ℝ)*r) |
| let b := EuclideanSpace.basisFun (Fin d ⊕ Fin d) ℝ |
| TensorEnergy.Bound (fun (a : ι → Fin d) (c : ϑ → Fin d) => |
| JetCalculus.jet (Sum.elim (fun i => b (conditionalSlotEmbedding d s a i)) |
| (fun j => b (conditionalSlotEmbedding d t c j))) o |
| (fun z => Real.log (Appell.laplace μ (fun _ => (1:ℝ)) z)) 0) |
| (((Fintype.card ι+Fintype.card ϑ+1:ℕ):ℝ)^(2*(Fintype.card ι+Fintype.card ϑ+1)) * |
| Appell.splitConstant (2*Real.pi^2*(1-ρ^2)) (Fintype.card ι) (Fintype.card ϑ)) := by |
| obtain ⟨hp,hm,hP⟩ := jointConditionalLaw_properties hF x hr hlam hl hρ0 hρ1 y |
| let := hp |
| have hβ : 0 ≤ 2*Real.pi^2*(1-ρ^2) := by |
| obtain ⟨ha,_⟩ := probability_time hρ0 hρ1 |
| positivity |
| exact (Appell.actual_jet_cumulant_energy hm hβ hP |
| (EuclideanSpace.basisFun (Fin d ⊕ Fin d) ℝ) l k hlN hlall hkN hkall hlne hkne o ho).submatrix |
| (conditionalSlotEmbedding d s) (conditionalSlotEmbedding d t) |
|
|
| lemma normalized_energy_factor {a : ℝ} (ha : a≠0) (B : ℝ) {j k : ℕ} |
| (hj : 0<j) (hk : 0<k) : |
| ((a^(j+k-1))⁻¹)^2*(B*a)^(j+k)=B^(j+k)/(a^(j+k-2)) := by |
| obtain ⟨j,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hj) |
| obtain ⟨k,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hk) |
| have h1 : j.succ+k.succ-1=j+k+1 := by omega |
| have h2 : j.succ+k.succ-2=j+k := by omega |
| have h3 : j.succ+k.succ=(j+k)+2 := by omega |
| rw [h1,h2,h3,mul_pow] |
| simp only [pow_add,pow_one,pow_two] |
| field_simp |
|
|
| theorem conditional_normalized_tensor_energy {d : ℕ} {F : Point d → ℝ} {lam : ℝ≥0} |
| (hF : Primitive F lam) (x : Point d) {r ρ : ℝ} (hr : 0<r) |
| (hlam : 0<lam) (hl : (lam:ℝ)*r^2 ≤ 1/2) (hρ0 : 0≤ρ) (hρ1 : ρ<1) (y : Point d) |
| {ι ϑ : Type*} [Fintype ι] [DecidableEq ι] [Fintype ϑ] [DecidableEq ϑ] |
| (s : ι → Bool) (t : ϑ → Bool) (l : List ι) (k : List ϑ) |
| (hlN : l.Nodup) (hlall : l.toFinset=Finset.univ) |
| (hkN : k.Nodup) (hkall : k.toFinset=Finset.univ) (hlne : l≠[]) (hkne : k≠[]) |
| (o : List (ι ⊕ ϑ)) (ho : o.Perm (l.map Sum.inl++k.map Sum.inr)) : |
| let μ := jointConditionalLaw F x r ρ y ((lam:ℝ)*r) |
| let b := EuclideanSpace.basisFun (Fin d ⊕ Fin d) ℝ |
| let n := Fintype.card ι+Fintype.card ϑ |
| TensorEnergy.Bound (fun (a : ι → Fin d) (c : ϑ → Fin d) => |
| ((1-ρ^2)^(n-1))⁻¹ * JetCalculus.jet (Sum.elim (fun i => b (conditionalSlotEmbedding d s a i)) |
| (fun j => b (conditionalSlotEmbedding d t c j))) o |
| (fun z => Real.log (Appell.laplace μ (fun _ => (1:ℝ)) z)) 0) |
| (((n+1:ℕ):ℝ)^(2*(n+1))*(2*Real.pi^2)^n * |
| (((Fintype.card ι).factorial:ℝ)*((Fintype.card ϑ).factorial:ℝ))^2 / |
| (1-ρ^2)^(n-2)) := by |
| dsimp only |
| have hj : 0<Fintype.card ι := by |
| apply Fintype.card_pos_iff.mpr |
| obtain ⟨i,_⟩ := List.exists_mem_of_ne_nil l hlne |
| exact ⟨i⟩ |
| have hk : 0<Fintype.card ϑ := by |
| apply Fintype.card_pos_iff.mpr |
| obtain ⟨i,_⟩ := List.exists_mem_of_ne_nil k hkne |
| exact ⟨i⟩ |
| have hb := (conditional_jet_cumulant_energy hF x hr hlam hl hρ0 hρ1 y |
| s t l k hlN hlall hkN hkall hlne hkne o ho).smul |
| (((1-ρ^2)^(Fintype.card ι+Fintype.card ϑ-1))⁻¹) |
| convert! hb using 1 |
| dsimp [Appell.splitConstant] |
| have he := normalized_energy_factor (probability_time hρ0 hρ1).1.ne' (2*Real.pi^2) hj hk |
| calc |
| _ = (((Fintype.card ι+Fintype.card ϑ+1:ℕ):ℝ)^(2*(Fintype.card ι+Fintype.card ϑ+1)) * |
| (((Fintype.card ι).factorial:ℝ)*((Fintype.card ϑ).factorial:ℝ))^2) * |
| ((2*Real.pi^2)^(Fintype.card ι+Fintype.card ϑ)/(1-ρ^2)^(Fintype.card ι+Fintype.card ϑ-2)) := by ring |
| _ = _ := by rw [←he]; ring |
|
|
| end LogConcaveSampling |
|
|
| end UpperProof |
| end |
| end |
| end |
|
|
| end OAI |
|
|
