| 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 |
|
|
