math / data /lean /OAI /Probability /IsingPerceptron /EnergyShift.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
32 kB
import Mathlib
import OAI.Probability.IsingPerceptron.VarianceOfConditionalCenterBound
namespace OAI
/-! Energy Shift. -/
noncomputable section
open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
namespace IsingPerceptron
variable {I : Type} [Fintype I] [MeasurableSpace I] [MeasurableSingletonClass I]
lemma energyRecursion_add_const (n : β„•) (b : β„• β†’ ℝ)
(ΞΌ : β„• β†’ ProbabilityMeasure (I β†’ ℝ)) (Ξ½ : Measure I) [IsProbabilityMeasure Ξ½]
(hΞΌ : βˆ€ i < n, ExponentialNormMoments (ΞΌ i : Measure (I β†’ ℝ)))
(hb : βˆ€ i < n, 0 < b i) (H : I β†’ ℝ) (c : ℝ) :
energyRecursion n b ΞΌ Ξ½ (fun x => c+H x) = c+energyRecursion n b ΞΌ Ξ½ H := by
induction n generalizing b ΞΌ H with
| zero => exact finiteLogIntegral_add_const Ξ½ H c
| succ n ih =>
change logMean (b 0) (ΞΌ 0 : Measure (I β†’ ℝ))
(fun a => energyRecursion n (fun i => b (i+1)) (fun i => ΞΌ (i+1)) Ξ½
((fun x => c+H x)+a)) = c+logMean (b 0) (ΞΌ 0 : Measure (I β†’ ℝ))
(fun a => energyRecursion n (fun i => b (i+1)) (fun i => ΞΌ (i+1)) Ξ½ (H+a))
have he (a : I β†’ ℝ) : ((fun x => c+H x)+a) = fun x => c+(H+a) x := by
ext x; simp only [Pi.add_apply]; ring
simp_rw [he,ih (fun i => b (i+1)) (fun i => ΞΌ (i+1))
(fun i hi => hΞΌ (i+1) (by omega)) (fun i hi => hb (i+1) (by omega))]
apply logMean_const_add _ (hb 0 (by omega)).ne'
exact integrable_exp_of_linearGrowth _ (hΞΌ 0 (by omega))
((measurable_energyRecursion n _ _ Ξ½).comp (measurable_const.add measurable_id))
((energyRecursion_linearGrowth n _ _ Ξ½ (fun i hi => hΞΌ (i+1) (by omega))
(fun i hi => hb (i+1) (by omega))).add_left H) _
def scalarShiftLaw (ΞΌ : ProbabilityMeasure (I β†’ ℝ)) (v : ℝβ‰₯0) : ProbabilityMeasure (I β†’ ℝ) :=
⟨((ΞΌ : Measure (I β†’ ℝ)).prod (gaussianReal 0 v)).map
(fun p : (I β†’ ℝ) Γ— ℝ => fun x => p.1 x+p.2),
inferInstance⟩
omit [MeasurableSpace I] [MeasurableSingletonClass I] in
lemma scalarShiftLaw_exponentialNormMoments (ΞΌ : ProbabilityMeasure (I β†’ ℝ))
(hΞΌ : ExponentialNormMoments (ΞΌ : Measure (I β†’ ℝ))) (v : ℝβ‰₯0) :
ExponentialNormMoments (scalarShiftLaw ΞΌ v : Measure (I β†’ ℝ)) := by
intro a
apply (integrable_map_measure (by fun_prop) (by fun_prop)).mpr
have hi := (hΞΌ |a|).mul_prod (gaussianReal_exponentialNormMoments 0 v |a|)
have hm : Measurable (fun p : (I β†’ ℝ) Γ— ℝ => fun x => p.1 x+p.2) := by fun_prop
apply hi.mono' ((hm.norm.const_mul a).exp.aestronglyMeasurable)
apply ae_of_all
rintro ⟨H,g⟩
simp only [Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)]
rw [← Real.exp_add]
apply Real.exp_le_exp.mpr
calc
a*β€–fun x => H x+gβ€– ≀ |a| *β€–fun x => H x+gβ€– :=
mul_le_mul_of_nonneg_right (le_abs_self _) (norm_nonneg _)
_ ≀ |a| *(β€–Hβ€–+β€–gβ€–) := by
gcongr
exact (norm_add_le H (fun _ : I => g)).trans (add_le_add le_rfl ((pi_norm_le_iff_of_nonneg (norm_nonneg g)).mpr (fun _ => le_rfl)))
_ = _ := by rw [Real.norm_eq_abs]; ring
omit [MeasurableSpace I] [MeasurableSingletonClass I] in
lemma logMean_scalarShift (ΞΌ : ProbabilityMeasure (I β†’ ℝ)) (v : ℝβ‰₯0)
(r : ℝ) {F : (I β†’ ℝ) β†’ ℝ} (hFm : Measurable F)
(hFi : Integrable (fun H => Real.exp (r*F H)) (ΞΌ : Measure (I β†’ ℝ)))
(hFc : βˆ€ H c, F (fun x => c+H x) = c+F H) (hr : r β‰  0) :
logMean r (scalarShiftLaw ΞΌ v : Measure (I β†’ ℝ)) F =
(v:ℝ)*r/2+logMean r (ΞΌ : Measure (I β†’ ℝ)) F := by
change Real.log (∫ p, Real.exp (r*F p) βˆ‚((ΞΌ : Measure (I β†’ ℝ)).prod (gaussianReal 0 v)).map
(fun p : (I β†’ ℝ) Γ— ℝ => fun x => p.1 x+p.2))/r = _
unfold logMean
rw [integral_map (by fun_prop) ((hFm.const_mul r).exp).aestronglyMeasurable]
have he (p : (I β†’ ℝ) Γ— ℝ) : Real.exp (r*F (fun x => p.1 x+p.2)) =
Real.exp (r*F p.1)*Real.exp (r*p.2) := by
rw [show (fun x => p.1 x+p.2) = (fun x => p.2+p.1 x) by ext x; ring,hFc]
rw [mul_add,Real.exp_add,mul_comm]
simp_rw [he]
rw [integral_prod_mul (fun H : I β†’ ℝ => Real.exp (r*F H)) (fun g : ℝ => Real.exp (r*g))]
have hg : (∫ g : ℝ, Real.exp (r*g) βˆ‚gaussianReal 0 v) = Real.exp ((v:ℝ)*r^2/2) := by
simpa [mgf] using (congrFun (mgf_fun_id_gaussianReal (ΞΌ := (0:ℝ)) (v := v)) r)
rw [hg,Real.log_mul (integral_exp_pos (ΞΌ : Measure (I β†’ ℝ)) F (b := r) hFi).ne' (Real.exp_ne_zero _),Real.log_exp]
field_simp [hr]
ring
theorem energyRecursion_scalarShift (n : β„•) (b : β„• β†’ ℝ)
(ΞΌ : β„• β†’ ProbabilityMeasure (I β†’ ℝ)) (Ξ½ : Measure I) [IsProbabilityMeasure Ξ½]
(hΞΌ : βˆ€ i < n, ExponentialNormMoments (ΞΌ i : Measure (I β†’ ℝ)))
(hb : βˆ€ i < n, 0 < b i) (v : β„• β†’ ℝβ‰₯0) (H : I β†’ ℝ) :
energyRecursion n b (fun i => scalarShiftLaw (ΞΌ i) (v i)) Ξ½ H =
(βˆ‘ i ∈ Finset.range n, b i*(v i:ℝ))/2+energyRecursion n b ΞΌ Ξ½ H := by
induction n generalizing b ΞΌ v H with
| zero => simp [energyRecursion,cascadeRecursion]
| succ n ih =>
let F : (I β†’ ℝ) β†’ ℝ := fun a => energyRecursion n (fun i => b (i+1))
(fun i => ΞΌ (i+1)) Ξ½ (H+a)
have hFm : Measurable F := (measurable_energyRecursion n _ _ Ξ½).comp
(measurable_const.add measurable_id)
have hFg : HasLinearGrowth F := (energyRecursion_linearGrowth n _ _ Ξ½
(fun i hi => hΞΌ (i+1) (by omega)) (fun i hi => hb (i+1) (by omega))).add_left H
have hFi : Integrable (fun a => Real.exp (b 0*F a)) (ΞΌ 0 : Measure (I β†’ ℝ)) :=
integrable_exp_of_linearGrowth _ (hΞΌ 0 (by omega)) hFm hFg _
have hFsi : Integrable (fun a => Real.exp (b 0*F a))
(scalarShiftLaw (ΞΌ 0) (v 0) : Measure (I β†’ ℝ)) :=
integrable_exp_of_linearGrowth _ (scalarShiftLaw_exponentialNormMoments _ (hΞΌ 0 (by omega)) _)
hFm hFg _
have hFc (a : I β†’ ℝ) (c : ℝ) : F (fun x => c+a x) = c+F a := by
dsimp [F]
rw [show H+(fun x => c+a x) = (fun x => c+(H+a) x) by ext x; simp [Pi.add_apply]; ring]
exact energyRecursion_add_const _ _ _ Ξ½ (fun i hi => hΞΌ (i+1) (by omega))
(fun i hi => hb (i+1) (by omega)) _ _
change logMean (b 0) (scalarShiftLaw (ΞΌ 0) (v 0) : Measure (I β†’ ℝ))
(fun a => energyRecursion n (fun i => b (i+1))
(fun i => scalarShiftLaw (ΞΌ (i+1)) (v (i+1))) Ξ½ (H+a)) = _
simp_rw [ih (fun i => b (i+1)) (fun i => ΞΌ (i+1))
(fun i hi => hΞΌ (i+1) (by omega)) (fun i hi => hb (i+1) (by omega))]
change logMean (b 0) (scalarShiftLaw (ΞΌ 0) (v 0) : Measure (I β†’ ℝ))
(fun a => (βˆ‘ i ∈ Finset.range n, b (i+1)*(v (i+1):ℝ))/2+F a) = _
rw [logMean_const_add _ (hb 0 (by omega)).ne' hFsi,
logMean_scalarShift _ _ _ hFm hFi hFc (hb 0 (by omega)).ne']
change _ = (βˆ‘ i ∈ Finset.range (n+1), b i*(v i:ℝ))/2+
logMean (b 0) (ΞΌ 0 : Measure (I β†’ ℝ)) F
rw [Finset.sum_range_succ']
ring
end IsingPerceptron
open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
namespace IsingPerceptron
abbrev EnrichedLabeledData (N n : β„•) (A : Type*) :=
EnrichedPoissonRoot N A Γ— (LabeledTree n Γ— (ForestVertex n β†’ Fin (EnrichedRootSize N) β†’ ℝ))
def enrichedCoordinateLaw {A : Type*} [MeasurableSpace A] (P : Measure A)
(r : ℝβ‰₯0) (N n : β„•) (b : β„• β†’ ℝ) : Measure (EnrichedLabeledData N n A) :=
((poissonMeasure r).prod ((Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1)).prod
(Measure.infinitePi (fun _ : β„• => P)))).prod
((labeledCascadeLaw n b : Measure (LabeledTree n)).prod (enrichedForestCoordinates N n))
instance enrichedCoordinateLaw_probability {A : Type*} [MeasurableSpace A]
(P : Measure A) [IsProbabilityMeasure P] (r : ℝβ‰₯0) (N n : β„•) (b : β„• β†’ ℝ) :
IsProbabilityMeasure (enrichedCoordinateLaw P r N n b) := by
unfold enrichedCoordinateLaw
infer_instance
def enrichedCoordinatePressure {N : β„•} {A : Type*} (n : β„•) (h : β„• β†’ ℝ)
(u : Fin N β†’ ℝ) (Ξ½ : Measure (Spin N)) (Ο† : A β†’ Spin N β†’ ℝ)
(p : EnrichedLabeledData N n A) : ℝ :=
(labeledEnergyLog n Ξ½ (enrichedPoissonBase n h u Ο† p.1)
(p.2.1,enrichedForest N n h u p.2.2) - N*h n/2) / N
def enrichedToNoise {N : β„•} {A : Type*} (n : β„•) (h : β„• β†’ ℝ) (u : Fin N β†’ ℝ)
(p : EnrichedLabeledData N n A) : EnrichedPoissonRoot N A Γ— NoiseTree (Spin N β†’ ℝ) n :=
(p.1,labeledNoiseJoin (Spin N β†’ ℝ) n (p.2.1,enrichedForest N n h u p.2.2))
lemma enrichedToNoise_preserving {N : β„•} {A : Type*} [MeasurableSpace A]
(P : Measure A) [IsProbabilityMeasure P] (r : ℝβ‰₯0) (n : β„•) (b h : β„• β†’ ℝ)
(u : Fin N β†’ ℝ) :
MeasurePreserving (enrichedToNoise (A := A) n h u) (enrichedCoordinateLaw P r N n b)
(((poissonMeasure r).prod ((Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1)).prod
(Measure.infinitePi (fun _ : β„• => P)))).prod
(noiseCascadeLaw (Spin N β†’ ℝ) n b (fun i => enrichedIncrementLaw N n h u (i+1)))) := by
have hf : Measurable (fun p : LabeledTree n Γ— (ForestVertex n β†’ Fin (EnrichedRootSize N) β†’ ℝ) =>
(p.1,enrichedForest N n h u p.2)) :=
measurable_fst.prodMk ((measurable_enrichedForest N n h u).comp measurable_snd)
have hp : MeasurePreserving
(fun p : LabeledTree n Γ— (ForestVertex n β†’ Fin (EnrichedRootSize N) β†’ ℝ) =>
labeledNoiseJoin (Spin N β†’ ℝ) n (p.1,enrichedForest N n h u p.2))
((labeledCascadeLaw n b : Measure (LabeledTree n)).prod (enrichedForestCoordinates N n))
(noiseCascadeLaw (Spin N β†’ ℝ) n b (fun i => enrichedIncrementLaw N n h u (i+1))) :=
⟨(measurable_labeledNoiseJoin (Spin N β†’ ℝ) n).comp hf,
labeledEnrichedCoordinates_law N n b h u⟩
exact (MeasurePreserving.id _).prod hp
theorem enrichedCoordinatePressure_eq_noise {N : β„•} {A : Type*} [MeasurableSpace A]
(P : Measure A) [IsProbabilityMeasure P] (r : ℝβ‰₯0) (n : β„•) (b h : β„• β†’ ℝ)
(hb : CascadeExponents n b) (u : Fin N β†’ ℝ) (Ξ½ : Measure (Spin N)) [IsProbabilityMeasure Ξ½]
{Ο† : A β†’ Spin N β†’ ℝ} (hm : Measurable Ο†) :
enrichedCoordinatePressure n h u Ξ½ Ο† =ᡐ[enrichedCoordinateLaw P r N n b]
(fun p => enrichedPoissonLog n b h u Ξ½ Ο† (enrichedToNoise n h u p) / N) := by
let Q := (poissonMeasure r).prod
((Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1)).prod
(Measure.infinitePi (fun _ : β„• => P)))
let ΞΌ := fun i => enrichedIncrementLaw N n h u (i+1)
have hpF : MeasurePreserving (enrichedForest N n h u) (enrichedForestCoordinates N n)
(markForestLaw (Spin N β†’ ℝ) n ΞΌ) :=
⟨measurable_enrichedForest N n h u,enrichedForest_law N n h u⟩
have hpT := (MeasurePreserving.id (labeledCascadeLaw n b : Measure (LabeledTree n))).prod hpF
have hp := (MeasurePreserving.id Q).prod hpT
have he := labeledEnergyLog_eq_cascade_random Q n b hb ΞΌ Ξ½ (measurable_enrichedPoissonBase n h u hm)
have he' : βˆ€α΅ p βˆ‚enrichedCoordinateLaw P r N n b,
labeledEnergyLog n Ξ½ (enrichedPoissonBase n h u Ο† p.1)
(p.2.1,enrichedForest N n h u p.2.2) =
cascadeEnergyLog n b ΞΌ Ξ½ (enrichedPoissonBase n h u Ο† p.1)
(labeledNoiseJoin (Spin N β†’ ℝ) n (p.2.1,enrichedForest N n h u p.2.2)) := by
apply ae_of_ae_map (p := fun p : EnrichedPoissonRoot N A Γ—
(LabeledTree n Γ— MarkForest (Spin N β†’ ℝ) n) =>
labeledEnergyLog n Ξ½ (enrichedPoissonBase n h u Ο† p.1) p.2 =
cascadeEnergyLog n b ΞΌ Ξ½ (enrichedPoissonBase n h u Ο† p.1)
(labeledNoiseJoin (Spin N β†’ ℝ) n p.2)) hp.measurable.aemeasurable
rw [show enrichedCoordinateLaw P r N n b = Q.prod
((labeledCascadeLaw n b : Measure (LabeledTree n)).prod (enrichedForestCoordinates N n)) from rfl,
hp.map_eq]
exact he
filter_upwards [he'] with p he
unfold enrichedCoordinatePressure enrichedPoissonLog enrichedToNoise
dsimp only
rw [he]
theorem enrichedCoordinatePressure_field_cap {N : β„•} (hN : 0 < N) (n : β„•) (b : β„• β†’ ℝ)
(hb : CascadeExponents n b) {h : β„• β†’ ℝ} (hh : Monotone h) (h0 : 0 ≀ h 0)
{H : ℝ} (hH : h n ≀ H) (u : Fin N β†’ ℝ) (hu : βˆ€ j, |u j| ≀ 2)
(Ξ½ : Measure (Spin N)) [IsProbabilityMeasure Ξ½]
{A : Type*} [MeasurableSpace A] (P : Measure A) [IsProbabilityMeasure P]
{Ο† : A β†’ Spin N β†’ ℝ} (hm : Measurable Ο†) {K : ℝ} (hK : 0 ≀ K)
(hΟ† : βˆ€ y x, |Ο† y x| ≀ K) (r : ℝβ‰₯0) {Ξ± : ℝ} (hr : (r:ℝ) ≀ Ξ±*N) :
let Q := enrichedCoordinateLaw P r N n b
let C := 4*∫ T, (Real.log (rawTreeTotal n T).toReal)^2 βˆ‚(rawCascadeLaw n b : Measure (RawTree n))
let X := enrichedCoordinatePressure n h u Ξ½ Ο†
MemLp X 2 Q ∧ Var[X;Q] ≀ (C+H+4+5*K^2*Ξ±)/N := by
have hv := enriched_field_cap_variance hN n b hb hh h0 hH u hu ν P hm hK hφ r hr
have hp := enrichedToNoise_preserving P r n b h u
have he := enrichedCoordinatePressure_eq_noise P r n b h hb u Ξ½ hm
have hL := hv.1.comp_measurePreserving hp
refine ⟨MemLp.ae_eq he.symm hL, ?_⟩
have ht := variance_map (X := fun p => enrichedPoissonLog n b h u Ξ½ Ο† p / N)
(hp.map_eq.symm β–Έ hv.1.aemeasurable) hp.measurable.aemeasurable
rw [hp.map_eq] at ht
simp only [Function.comp_def] at ht
rw [variance_congr he, ← ht]
exact hv.2
end IsingPerceptron
open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
namespace IsingPerceptron
def nodeAddress : (n : β„•) β†’ Option (ForestVertex n) β†’ List ChildLabel
| _, none => []
| 0, some v => v.elim
| n+1, some (m,i,v) => (m,i) :: nodeAddress n v
lemma nodeAddress_injective (n : β„•) : Function.Injective (nodeAddress n) := by
induction n with
| zero =>
intro v w _
cases v with
| none => cases w with
| none => rfl
| some w => exact w.elim
| some v => exact v.elim
| succ n ih =>
intro v w h
cases v with
| none => cases w with
| none => rfl
| some w => simp [nodeAddress] at h
| some v => cases w with
| none => simp [nodeAddress] at h
| some w =>
rcases v with ⟨m,i,v⟩
rcases w with ⟨m',i',w⟩
simp only [nodeAddress,List.cons.injEq,Prod.mk.injEq] at h
rcases h with ⟨⟨rfl,rfl⟩,h⟩
rw [ih h]
def nodeAt : (n : β„•) β†’ LabeledLeaf n β†’ Fin (n+1) β†’ Option (ForestVertex n)
| 0, _, _ => none
| n+1, Ξ³, i => Fin.cases none (fun j => some (Ξ³.1.1,Ξ³.1.2,nodeAt n Ξ³.2 j)) i
lemma nodeAddress_nodeAt (n : β„•) (Ξ³ : LabeledLeaf n) (i : Fin (n+1)) :
nodeAddress n (nodeAt n Ξ³ i) = (labeledAddress n Ξ³).take i := by
induction n with
| zero => simp [nodeAt,nodeAddress,labeledAddress]
| succ n ih =>
refine Fin.cases ?_ (fun j => ?_) i
Β· simp [nodeAt,nodeAddress]
Β· simp [nodeAt,nodeAddress,labeledAddress,ih]
lemma nodeAddress_length_some (n : β„•) (v : ForestVertex n) :
(nodeAddress n (some v)).length = forestVertexDepth n v+1 := by
induction n with
| zero => exact v.elim
| succ n ih =>
rcases v with ⟨m,i,_ | v⟩
Β· simp [nodeAddress,forestVertexDepth]
Β· simp only [nodeAddress,List.length_cons,ih,forestVertexDepth,Nat.add_assoc]
lemma nodeAddress_nodeAt_length (n : β„•) (Ξ³ : LabeledLeaf n) (i : Fin (n+1)) :
(nodeAddress n (nodeAt n Ξ³ i)).length = i := by
rw [nodeAddress_nodeAt,List.length_take,labeledAddress_length]
exact Nat.min_eq_left (Nat.le_of_lt_succ i.isLt)
def enrichedNodeTag {N n : β„•} (v : Option (ForestVertex n)) : EnrichedBlock N β†’ β„•
| .inl a => Nat.pair 0 (Encodable.encode ((nodeAddress n v).length,nodeAddress n v,a))
| .inr ⟨j,t⟩ => Nat.pair (j+1) (Encodable.encode ((nodeAddress n v).length,nodeAddress n v,t))
lemma enrichedNodeTag_injective (N n : β„•) :
Function.Injective (fun p : Option (ForestVertex n) Γ— EnrichedBlock N => enrichedNodeTag p.1 p.2) := by
rintro ⟨v,a⟩ ⟨w,b⟩ h
cases a with
| inl a => cases b with
| inl b =>
have he := Encodable.encode_inj.mp (Nat.pair_eq_pair.mp h).2
have hv : v = w := nodeAddress_injective n (congrArg (fun p => p.2.1) he)
have hab : a = b := congrArg (fun p => p.2.2) he
subst w; subst b; rfl
| inr b =>
have h' := (Nat.pair_eq_pair.mp h).1
omega
| inr a => cases b with
| inl b =>
have h' := (Nat.pair_eq_pair.mp h).1
omega
| inr b =>
rcases a with ⟨j,t⟩
rcases b with ⟨k,s⟩
have hj : j = k := Fin.ext (by have h' := (Nat.pair_eq_pair.mp h).1; exact Nat.add_right_cancel h')
subst k
have he := Encodable.encode_inj.mp (Nat.pair_eq_pair.mp h).2
have hv : v = w := nodeAddress_injective n (congrArg (fun p => p.2.1) he)
have hts : t = s := congrArg (fun p => p.2.2) he
subst w; subst s; rfl
def enrichedGaussianNodes (N n : β„•) (g : β„• β†’ ℝ)
(v : Option (ForestVertex n)) (j : Fin (EnrichedRootSize N)) : ℝ :=
g (enrichedNodeTag v ((Fintype.equivFin (EnrichedBlock N)).symm j))
lemma measurable_enrichedGaussianNodes (N n : β„•) :
Measurable (enrichedGaussianNodes N n) := by
unfold enrichedGaussianNodes
fun_prop
theorem enrichedGaussianNodes_law (N n : β„•) :
gaussianCoordinates.map (enrichedGaussianNodes N n) =
Measure.infinitePi (fun _ : Option (ForestVertex n) =>
Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1)) := by
let t : Option (ForestVertex n) Γ— Fin (EnrichedRootSize N) β†’ β„• :=
fun p => enrichedNodeTag p.1 ((Fintype.equivFin (EnrichedBlock N)).symm p.2)
have ht : Function.Injective t := by
intro p q h
have he := @enrichedNodeTag_injective N n
(p.1,(Fintype.equivFin (EnrichedBlock N)).symm p.2)
(q.1,(Fintype.equivFin (EnrichedBlock N)).symm q.2) h
have he' := Prod.mk.inj he
exact Prod.ext he'.1 ((Fintype.equivFin (EnrichedBlock N)).symm.injective he'.2)
have hp := gaussian_pullback_measurePreserving t ht
change gaussianCoordinates.map
((MeasurableEquiv.curry (Option (ForestVertex n)) (Fin (EnrichedRootSize N)) ℝ) ∘
(fun g => fun p => g (t p))) = _
rw [← Measure.map_map (MeasurableEquiv.curry _ _ _).measurable hp.measurable,hp.map_eq,
Measure.infinitePi_map_curry (fun (_ : Option (ForestVertex n)) (_ : Fin (EnrichedRootSize N)) => gaussianReal 0 1)]
simp only [Measure.infinitePi_eq_pi]
theorem enrichedGaussianRootForest_law (N n : β„•) :
gaussianCoordinates.map (fun g =>
(enrichedGaussianNodes N n g none, fun v => enrichedGaussianNodes N n g (some v))) =
(Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1)).prod
(enrichedForestCoordinates N n) := by
change gaussianCoordinates.map
((fun q : Option (ForestVertex n) β†’ Fin (EnrichedRootSize N) β†’ ℝ =>
(q none,fun v => q (some v))) ∘ enrichedGaussianNodes N n) = _
rw [← Measure.map_map (by fun_prop) (measurable_enrichedGaussianNodes N n),enrichedGaussianNodes_law]
have he := infinitePi_option_split
(Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1))
(fun _ : ForestVertex n => Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1))
have hc : (fun i : Option (ForestVertex n) => i.elim
(Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1))
(fun _ => Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1))) =
(fun _ => Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1)) := by
funext i; cases i <;> rfl
simpa only [hc,enrichedForestCoordinates] using he
lemma cylinderField_tag (j : β„•) (a : β„• β†’β‚€ ℝ) (g : β„• β†’ ℝ) :
cylinderField (tagCoefficients j a) g = cylinderField a (fun i => g (Nat.pair j i)) := by
unfold cylinderField tagCoefficients
rw [Finsupp.sum_mapDomain_index_inj (pair_left_injective j)]
lemma cylinderField_feature {J : Type*} [Fintype J] (t : J β†’ β„•) (a : J β†’ ℝ) (g : β„• β†’ ℝ) :
cylinderField (featureCoefficients t a) g = βˆ‘ j, a j*g (t j) := by
classical
rw [featureCoefficients,cylinderField_finset_sum]
apply Finset.sum_congr rfl
intro j _
exact Finsupp.sum_single_index (by simp)
def edgeAt : (n : β„•) β†’ LabeledLeaf n β†’ Fin n β†’ ForestVertex n
| 0, _, i => i.elim0
| n+1, Ξ³, i => (Ξ³.1.1,Ξ³.1.2,nodeAt n Ξ³.2 i)
lemma nodeAt_zero (n : β„•) (Ξ³ : LabeledLeaf n) : nodeAt n Ξ³ 0 = none := by
cases n <;> simp [nodeAt]
lemma nodeAt_succ (n : β„•) (Ξ³ : LabeledLeaf n) (i : Fin n) :
nodeAt n Ξ³ i.succ = some (edgeAt n Ξ³ i) := by
cases n with
| zero => exact i.elim0
| succ n => simp [nodeAt,edgeAt]
lemma labeledEnergy_edge_sum {I : Type} (n : β„•) (g : ForestVertex n β†’ I β†’ ℝ)
(Ξ³ : LabeledLeaf n) (H : I β†’ ℝ) (x : I) :
labeledEnergy n (markForestOfCoords (I β†’ ℝ) n g) Ξ³ H x =
H x + βˆ‘ i : Fin n, g (edgeAt n Ξ³ i) x := by
induction n generalizing H with
| zero => simp [labeledEnergy]
| succ n ih =>
rw [labeledEnergy,markForestOfCoords,ih,Fin.sum_univ_succ]
simp only [edgeAt,nodeAt_zero,nodeAt_succ,Pi.add_apply]
ring
lemma labeledEnergy_node_sum {I : Type} (n : β„•) (g : Option (ForestVertex n) β†’ I β†’ ℝ)
(Ξ³ : LabeledLeaf n) (H : I β†’ ℝ) (x : I) :
labeledEnergy n (markForestOfCoords (I β†’ ℝ) n (fun v => g (some v))) Ξ³ (H+g none) x =
H x + βˆ‘ i : Fin (n+1), g (nodeAt n Ξ³ i) x := by
rw [labeledEnergy_edge_sum,Fin.sum_univ_succ]
simp only [nodeAt_zero,nodeAt_succ,Pi.add_apply]
ring
lemma enrichedIncrement_nodes (N n : β„•) (h : β„• β†’ ℝ) (u : Fin N β†’ ℝ) (i : β„•)
(g : β„• β†’ ℝ) (v : Option (ForestVertex n)) (x : Spin N) :
enrichedIncrement N n h u i (enrichedGaussianNodes N n g v) x =
βˆ‘ a : EnrichedBlock N, enrichedLevelCoefficient n h u i x a * g (enrichedNodeTag v a) := by
unfold enrichedIncrement enrichedCoefficientsFin enrichedGaussianNodes
exact (Fintype.equivFin (EnrichedBlock N)).symm.sum_comp
(fun a => enrichedLevelCoefficient n h u i x a * g (enrichedNodeTag v a))
lemma cylinderField_external_nodes {N : β„•} (n : β„•) (h : β„• β†’ ℝ)
(x : Spin N) (Ξ³ : LabeledLeaf n) (g : β„• β†’ ℝ) :
cylinderField (tagCoefficients 0 (externalFieldCoefficients n h (x,Ξ³))) g =
βˆ‘ i : Fin (n+1), βˆ‘ a : Fin N,
pathAmplitude h i * spinValue (x a) * g (enrichedNodeTag (nodeAt n Ξ³ i) (.inl a)) := by
rw [cylinderField_tag,externalFieldCoefficients,treeFieldCoefficients,cylinderField_feature,
Fintype.sum_prod_type]
simp only [enrichedNodeTag]
simp_rw [nodeAddress_nodeAt_length,nodeAddress_nodeAt]
simp only [treeFeatureTag]
lemma cylinderField_monomial_nodes {N : β„•} (n : β„•) (j : Fin N) (c : ℝ)
(x : Spin N) (Ξ³ : LabeledLeaf n) (g : β„• β†’ ℝ) :
cylinderField (tagCoefficients (j+1) (c β€’ monomialCoefficients n (monomialIndex j).1
(monomialIndex j).2 (x,Ξ³))) g =
βˆ‘ i : Fin (n+1), βˆ‘ a : Fin (monomialIndex j).1 β†’ Fin N,
(c * pathAmplitude (monomialPath n (monomialIndex j).2) i *
tensorFeature (monomialIndex j).1 (spinCoordinate x) a) *
g (enrichedNodeTag (nodeAt n γ i) (.inr ⟨j,a⟩)) := by
rw [cylinderField_tag,cylinderField_smul,monomialCoefficients,treeFieldCoefficients,
cylinderField_feature,Fintype.sum_prod_type,Finset.mul_sum]
apply Finset.sum_congr rfl
intro i _
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro a _
simp only [enrichedNodeTag]
simp_rw [nodeAddress_nodeAt_length,nodeAddress_nodeAt]
simp only [treeFeatureTag]
ring
lemma cylinderField_enriched_nodes {N : β„•} (n : β„•) (h : β„• β†’ ℝ) (u : Fin N β†’ ℝ)
(x : Spin N) (Ξ³ : LabeledLeaf n) (g : β„• β†’ ℝ) :
cylinderField (enrichedCoefficients n h u (x,Ξ³)) g =
βˆ‘ i : Fin (n+1), βˆ‘ a : EnrichedBlock N,
enrichedLevelCoefficient n h u i x a * g (enrichedNodeTag (nodeAt n Ξ³ i) a) := by
classical
rw [enrichedCoefficients,cylinderField_finset_sum,Fin.sum_univ_succ]
simp only [Fin.cases_zero,Fin.cases_succ,Fin.val_zero,Fin.val_succ,
cylinderField_external_nodes,cylinderField_monomial_nodes]
simp only [Fintype.sum_sum_type,Fintype.sum_sigma,enrichedLevelCoefficient,
Finset.sum_add_distrib]
congr 1
exact Finset.sum_comm
theorem enrichedEnergy_eq_cylinder {N : β„•} (n : β„•) (h : β„• β†’ ℝ) (u : Fin N β†’ ℝ)
(g : β„• β†’ ℝ) (H : Spin N β†’ ℝ) (x : Spin N) (Ξ³ : LabeledLeaf n) :
labeledEnergy n (enrichedForest N n h u
(fun v => enrichedGaussianNodes N n g (some v))) Ξ³
(H+enrichedIncrement N n h u 0 (enrichedGaussianNodes N n g none)) x =
H x + cylinderField (enrichedCoefficients n h u (x,Ξ³)) g := by
let F : Option (ForestVertex n) β†’ Spin N β†’ ℝ := fun v =>
enrichedIncrement N n h u (nodeAddress n v).length (enrichedGaussianNodes N n g v)
have he := labeledEnergy_node_sum n F Ξ³ H x
have hf : (fun v => F (some v)) =
(fun v => enrichedIncrement N n h u (forestVertexDepth n v+1)
(enrichedGaussianNodes N n g (some v))) := by
funext v
simp only [F,nodeAddress_length_some]
have h0 : F none = enrichedIncrement N n h u 0 (enrichedGaussianNodes N n g none) := by
simp only [F,nodeAddress,List.length_nil]
rw [hf,h0] at he
rw [cylinderField_enriched_nodes]
simpa only [F,nodeAddress_nodeAt_length,enrichedIncrement_nodes,enrichedForest] using he
end IsingPerceptron
open MeasureTheory ProbabilityTheory Filter Set
open scoped BigOperators Topology ENNReal NNReal
namespace IsingPerceptron
private lemma preserving_three_rotate {A B C : Type*}
[MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C]
(μ : Measure A) (ν : Measure B) (ρ : Measure C) [SFinite μ] [SFinite ν] [SFinite ρ] :
MeasurePreserving (fun p : (A Γ— B) Γ— C => (p.1.1,(p.2,p.1.2)))
((μ.prod ν).prod ρ) (μ.prod (ρ.prod ν)) :=
((MeasurePreserving.id ΞΌ).prod Measure.measurePreserving_swap).comp
(measurePreserving_prodAssoc μ ν ρ)
private lemma preserving_four_shuffle {A B C D : Type*}
[MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C] [MeasurableSpace D]
(ΞΌ : Measure A) (Ξ½ : Measure B) (ρ : Measure C) (Ο„ : Measure D)
[SFinite ΞΌ] [SFinite Ξ½] [SFinite ρ] [SFinite Ο„] :
MeasurePreserving (fun p : (A Γ— B) Γ— (C Γ— D) => ((p.1.1,p.2.1),(p.1.2,p.2.2)))
((ΞΌ.prod Ξ½).prod (ρ.prod Ο„)) ((ΞΌ.prod ρ).prod (Ξ½.prod Ο„)) := by
have h1 := (measurePreserving_prodAssoc (ΞΌ.prod Ξ½) ρ Ο„).symm MeasurableEquiv.prodAssoc
have h2 := ((measurePreserving_prodAssoc μ ρ ν).symm MeasurableEquiv.prodAssoc).comp
(preserving_three_rotate μ ν ρ)
exact (measurePreserving_prodAssoc (ΞΌ.prod ρ) Ξ½ Ο„).comp
((h2.prod (MeasurePreserving.id Ο„)).comp h1)
abbrev EnrichedCylinderBase (n : β„•) (A : Type*) := (β„• Γ— (β„• β†’ A)) Γ— LabeledTree n
abbrev EnrichedCylinderData (n : β„•) (A : Type*) := EnrichedCylinderBase n A Γ— (β„• β†’ ℝ)
def enrichedCylinderBaseLaw {A : Type*} [MeasurableSpace A] (P : Measure A)
(r : ℝβ‰₯0) (n : β„•) (b : β„• β†’ ℝ) : Measure (EnrichedCylinderBase n A) :=
((poissonMeasure r).prod (Measure.infinitePi (fun _ : β„• => P))).prod (labeledCascadeLaw n b)
def enrichedCylinderLaw {A : Type*} [MeasurableSpace A] (P : Measure A)
(r : ℝβ‰₯0) (n : β„•) (b : β„• β†’ ℝ) : Measure (EnrichedCylinderData n A) :=
(enrichedCylinderBaseLaw P r n b).prod gaussianCoordinates
instance enrichedCylinderBaseLaw_probability {A : Type*} [MeasurableSpace A]
(P : Measure A) [IsProbabilityMeasure P] (r : ℝβ‰₯0) (n : β„•) (b : β„• β†’ ℝ) :
IsProbabilityMeasure (enrichedCylinderBaseLaw P r n b) := by
unfold enrichedCylinderBaseLaw
infer_instance
instance enrichedCylinderLaw_probability {A : Type*} [MeasurableSpace A]
(P : Measure A) [IsProbabilityMeasure P] (r : ℝβ‰₯0) (n : β„•) (b : β„• β†’ ℝ) :
IsProbabilityMeasure (enrichedCylinderLaw P r n b) := by
unfold enrichedCylinderLaw
infer_instance
def enrichedCylinderToCoordinates (N n : β„•) {A : Type*}
(p : EnrichedCylinderData n A) : EnrichedLabeledData N n A :=
((p.1.1.1,(enrichedGaussianNodes N n p.2 none,p.1.1.2)),
(p.1.2,fun v => enrichedGaussianNodes N n p.2 (some v)))
theorem enrichedCylinderToCoordinates_preserving {A : Type*} [MeasurableSpace A]
(P : Measure A) [IsProbabilityMeasure P] (r : ℝβ‰₯0) (N n : β„•) (b : β„• β†’ ℝ) :
MeasurePreserving (enrichedCylinderToCoordinates (A := A) N n)
(enrichedCylinderLaw P r n b) (enrichedCoordinateLaw P r N n b) := by
let ΞΌ := poissonMeasure r
let Ξ½ := Measure.infinitePi (fun _ : β„• => P)
let ρ := (labeledCascadeLaw n b : Measure (LabeledTree n))
let Ξ³ := Measure.pi (fun _ : Fin (EnrichedRootSize N) => gaussianReal 0 1)
let Ο„ := enrichedForestCoordinates N n
have hn : MeasurePreserving (fun g =>
(enrichedGaussianNodes N n g none,fun v => enrichedGaussianNodes N n g (some v)))
gaussianCoordinates (Ξ³.prod Ο„) :=
⟨(by unfold enrichedGaussianNodes; fun_prop),enrichedGaussianRootForest_law N n⟩
have h1 := (MeasurePreserving.id ((μ.prod ν).prod ρ)).prod hn
have h2 := preserving_four_shuffle (ΞΌ.prod Ξ½) ρ Ξ³ Ο„
have h3 := (preserving_three_rotate ΞΌ Ξ½ Ξ³).prod (MeasurePreserving.id (ρ.prod Ο„))
exact h3.comp (h2.comp h1)
def enrichedCylinderPressure {N : β„•} {A : Type*} (n : β„•) (h : β„• β†’ ℝ)
(u : Fin N β†’ ℝ) (Ξ½ : Measure (Spin N)) (Ο† : A β†’ Spin N β†’ ℝ)
(p : EnrichedCylinderData n A) : ℝ :=
(Real.log (∫ s, Real.exp (patternBase Ο† (fun i : Fin p.1.1.1 => p.1.1.2 i) s.1 +
cylinderField (enrichedCoefficients n h u s) p.2) βˆ‚labeledSpinReference n Ξ½ p.1.2) - N*h n/2)/N
theorem enrichedCylinderPressure_eq_coordinates {N : β„•} {A : Type*}
(n : β„•) (h : β„• β†’ ℝ) (u : Fin N β†’ ℝ) (Ξ½ : Measure (Spin N))
(Ο† : A β†’ Spin N β†’ ℝ) (p : EnrichedCylinderData n A) :
enrichedCylinderPressure n h u Ξ½ Ο† p =
enrichedCoordinatePressure n h u Ξ½ Ο† (enrichedCylinderToCoordinates N n p) := by
unfold enrichedCylinderPressure enrichedCoordinatePressure enrichedCylinderToCoordinates
labeledEnergyLog enrichedPoissonBase enrichedBaseEnergy rootPrefix
dsimp only
congr 3
apply integral_congr_ae
filter_upwards [] with s
congr 1
exact (enrichedEnergy_eq_cylinder n h u p.2
(patternBase Ο† (fun i : Fin p.1.1.1 => p.1.1.2 i)) s.1 s.2).symm
theorem enrichedCylinderPressure_field_cap {N : β„•} (hN : 0 < N) (n : β„•) (b : β„• β†’ ℝ)
(hb : CascadeExponents n b) {h : β„• β†’ ℝ} (hh : Monotone h) (h0 : 0 ≀ h 0)
{H : ℝ} (hH : h n ≀ H) (u : Fin N β†’ ℝ) (hu : βˆ€ j, |u j| ≀ 2)
(Ξ½ : Measure (Spin N)) [IsProbabilityMeasure Ξ½]
{A : Type*} [MeasurableSpace A] (P : Measure A) [IsProbabilityMeasure P]
{Ο† : A β†’ Spin N β†’ ℝ} (hm : Measurable Ο†) {K : ℝ} (hK : 0 ≀ K)
(hΟ† : βˆ€ y x, |Ο† y x| ≀ K) (r : ℝβ‰₯0) {Ξ± : ℝ} (hr : (r:ℝ) ≀ Ξ±*N) :
let Q := enrichedCylinderLaw P r n b
let C := 4*∫ T, (Real.log (rawTreeTotal n T).toReal)^2 βˆ‚(rawCascadeLaw n b : Measure (RawTree n))
let X := enrichedCylinderPressure n h u Ξ½ Ο†
MemLp X 2 Q ∧ Var[X;Q] ≀ (C+H+4+5*K^2*Ξ±)/N := by
have hv := enrichedCoordinatePressure_field_cap hN n b hb hh h0 hH u hu ν P hm hK hφ r hr
have hp := enrichedCylinderToCoordinates_preserving P r N n b
have he : enrichedCylinderPressure n h u Ξ½ Ο† =
(enrichedCoordinatePressure n h u Ξ½ Ο†) ∘ enrichedCylinderToCoordinates N n := by
funext p
exact enrichedCylinderPressure_eq_coordinates n h u Ξ½ Ο† p
have hL := hv.1.comp_measurePreserving hp
refine ⟨he β–Έ hL, ?_⟩
have ht := variance_map (X := enrichedCoordinatePressure n h u Ξ½ Ο†)
(hp.map_eq.symm β–Έ hv.1.aemeasurable) hp.measurable.aemeasurable
rw [hp.map_eq] at ht
rw [he, ← ht]
exact hv.2
end IsingPerceptron
end
end OAI