| import OAI.Probability.InvariantIsing.Arrays.NSpinTensorFrozenCGF |
| import OAI.Probability.InvariantIsing.Arrays.NSpinTensorHaarFluctuation |
|
|
| namespace OAI |
|
|
| /-! The actual flat spin/leaf pressure and marked-cascade pressure have the same law. -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory IsingPerceptron |
| open scoped BigOperators NNReal ENNReal |
|
|
| namespace InvariantIsing |
|
|
| def tensorFlatToNoise {N m k : ℕ} (I : Fin m → Finset (Fin N)) |
| (degree : Fin k → Fin m → ℕ) (n : ℕ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) |
| (p : LabeledTree n × (ℕ → ℝ)) : |
| (SpinTensorIndex I degree → ℝ) × NoiseTree (SpinTensorIndex I degree → ℝ) n := |
| let q := tensorFlatToCoordinates I degree n v p |
| (q.1, labeledNoiseJoin (SpinTensorIndex I degree → ℝ) n |
| (q.2.1, markForestOfCoords (SpinTensorIndex I degree → ℝ) n q.2.2)) |
|
|
| theorem tensorFlatToNoise_measurePreserving {N m k : ℕ} (I : Fin m → Finset (Fin N)) |
| (degree : Fin k → Fin m → ℕ) (n : ℕ) (b : ℕ → ℝ) |
| (v : ℕ → SpinTensorIndex I degree → ℝ≥0) : |
| MeasurePreserving (tensorFlatToNoise I degree n v) |
| ((labeledCascadeLaw n b : Measure (LabeledTree n)).prod gaussianCoordinates) |
| (tensorRootTreeLaw I degree n b (fun i => v (i + 1)) (v 0)) := by |
| have hp : MeasurePreserving (fun q : TensorCoordinateData I degree n => |
| labeledNoiseJoin (SpinTensorIndex I degree → ℝ) n |
| (q.1, markForestOfCoords (SpinTensorIndex I degree → ℝ) n q.2)) |
| (tensorCoordinateLaw I degree n b (fun i => v (i + 1))) |
| (tensorCascadeLaw I degree n b (fun i => v (i + 1))) := |
| ⟨by fun_prop, labeledNoiseCoordinates_law (SpinTensorIndex I degree → ℝ) n b |
| (fun i => tensorGaussianLaw I degree (v (i + 1)))⟩ |
| have h := ((MeasurePreserving.id (tensorGaussianLaw I degree (v 0) : |
| Measure (SpinTensorIndex I degree → ℝ))).prod hp).comp |
| (tensorFlatToCoordinates_measurePreserving I degree n b v) |
| convert h using 1 |
| · rfl |
| · rfl |
|
|
| private lemma spinTensorEnergy_labeled {N m k : ℕ} (U : Rotation N) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (z : SpinTensorIndex I degree → ℝ) |
| (G : ForestVertex n → SpinTensorIndex I degree → ℝ) (leaf : LabeledLeaf n) (σ : Spin N) : |
| spinTensorEnergy U I degree amplitude |
| (labeledEnergy n (markForestOfCoords (SpinTensorIndex I degree → ℝ) n G) leaf z) σ = |
| spinTensorEnergy U I degree amplitude z σ + |
| ∑ i : Fin n, spinTensorEnergy U I degree amplitude (G (edgeAt n leaf i)) σ := by |
| unfold spinTensorEnergy |
| simp only [labeledEnergy_edge_sum, add_mul, Finset.sum_add_distrib] |
| congr 1 |
| simp_rw [Finset.sum_mul] |
| rw [Finset.sum_comm] |
|
|
| private lemma tensorCoordinateLog_eq_terminal {N m k : ℕ} |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (z : SpinTensorIndex I degree → ℝ) (q : TensorCoordinateData I degree n) : |
| Real.log (∫ x, Real.exp (tensorLabeledEnergy eig U c I degree amplitude n z |
| (tensorEnergyCoordinates U I degree amplitude n q) x) |
| ∂tensorLabeledReference N n (tensorEnergyCoordinates U I degree amplitude n q)) = |
| Real.log (∫ leaf, Real.exp (spinTensorTerminal eig U c I degree amplitude |
| (labeledEnergy n (markForestOfCoords (SpinTensorIndex I degree → ℝ) n q.2) leaf z)) |
| ∂labeledLeafLaw n q.1) := by |
| let H := tensorSpinBaseEnergy eig U c I degree amplitude z |
| let G := markForestOfCoords (Spin N → ℝ) n |
| (fun w => spinTensorEnergy U I degree amplitude (q.2 w)) |
| have he (x : Spin N × LabeledLeaf n) : tensorLabeledEnergy eig U c I degree amplitude n z |
| (tensorEnergyCoordinates U I degree amplitude n q) x = labeledEnergy n G x.2 H x.1 := by |
| rw [labeledEnergy_edge_sum] |
| rfl |
| simp_rw [he] |
| change labeledEnergyLog n (uniformSpinPrior N : Measure (Spin N)) H (q.1, G) = _ |
| rw [labeledEnergyLog_eq_leaf] |
| apply congrArg Real.log |
| apply integral_congr_ae |
| refine ae_of_all _ fun leaf => ?_ |
| apply congrArg Real.exp |
| rw [finiteLogIntegral_uniformSpinPrior] |
| unfold spinTensorTerminal |
| congr 1 |
| funext σ |
| rw [spinTensorEnergy_labeled, labeledEnergy_edge_sum] |
| change (rotatedEnergy eig U σ + fieldEnergy c σ + spinTensorEnergy U I degree amplitude z σ) + _ = _ |
| ring |
|
|
| /-- On every good marked tree the coordinate partition is exactly the |
| actual marked-cascade partition, uniformly in its rotation and root mark. -/ |
| theorem tensorCoordinateLog_eq_noise {N m k : ℕ} |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (z : SpinTensorIndex I degree → ℝ) (q : TensorCoordinateData I degree n) |
| (hg : GoodNoiseTree (SpinTensorIndex I degree → ℝ) n |
| (labeledNoiseJoin (SpinTensorIndex I degree → ℝ) n |
| (q.1, markForestOfCoords (SpinTensorIndex I degree → ℝ) n q.2))) |
| (ht : 0 < noiseTreeTotal (SpinTensorIndex I degree → ℝ) n |
| (labeledNoiseJoin (SpinTensorIndex I degree → ℝ) n |
| (q.1, markForestOfCoords (SpinTensorIndex I degree → ℝ) n q.2)) ∧ |
| noiseTreeTotal (SpinTensorIndex I degree → ℝ) n |
| (labeledNoiseJoin (SpinTensorIndex I degree → ℝ) n |
| (q.1, markForestOfCoords (SpinTensorIndex I degree → ℝ) n q.2)) < ∞) : |
| Real.log (∫ x, Real.exp (tensorLabeledEnergy eig U c I degree amplitude n z |
| (tensorEnergyCoordinates U I degree amplitude n q) x) |
| ∂tensorLabeledReference N n (tensorEnergyCoordinates U I degree amplitude n q)) = |
| tensorCascadeLog eig U c I degree amplitude n z |
| (labeledNoiseJoin (SpinTensorIndex I degree → ℝ) n |
| (q.1, markForestOfCoords (SpinTensorIndex I degree → ℝ) n q.2)) := by |
| rw [tensorCoordinateLog_eq_terminal] |
| have he := labeled_terminal_integral n q.1 |
| (markForestOfCoords (SpinTensorIndex I degree → ℝ) n q.2) hg ht |
| (X := fun _ => spinTensorTerminal eig U c I degree amplitude) (u := fun _ p => p.1 + p.2) |
| (fun _ => measurable_spinTensorTerminal eig U c I degree amplitude) |
| (fun _ => measurable_fst.add measurable_snd) z |
| simp only [labeledEnergy_terminal] at he |
| exact congrArg Real.log he |
|
|
|
|
| /-- The good-tree event is independent of the terminal energy, so this |
| identity holds simultaneously for every rotation on one full-measure set. -/ |
| theorem tensorFlatLog_eq_noise_ae {N m k : ℕ} (eig c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (b : ℕ → ℝ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) (hb : CascadeExponents n b) : |
| ∀ᵐ p : LabeledTree n × (ℕ → ℝ) |
| ∂(labeledCascadeLaw n b : Measure (LabeledTree n)).prod gaussianCoordinates, |
| ∀ U : Rotation N, tensorFlatLog eig U c I degree amplitude n v p = |
| tensorCascadeLog eig U c I degree amplitude n (tensorFlatToNoise I degree n v p).1 |
| (tensorFlatToNoise I degree n v p).2 := by |
| let M := (SpinTensorIndex I degree → ℝ) |
| let ν := fun i => tensorGaussianLaw I degree (v (i + 1)) |
| let : IsProbabilityMeasure (tensorCascadeLaw I degree n b (fun i => v (i + 1))) := |
| (noiseCascadeLaw M n b ν).prop |
| have hp := tensorFlatToNoise_measurePreserving I degree n b v |
| have hg : ∀ᵐ T ∂tensorCascadeLaw I degree n b (fun i => v (i + 1)), GoodNoiseTree M n T := |
| noiseCascade_good M n b hb ν |
| have ht : ∀ᵐ T ∂tensorCascadeLaw I degree n b (fun i => v (i + 1)), |
| 0 < noiseTreeTotal M n T ∧ noiseTreeTotal M n T < ∞ := by |
| apply ae_of_ae_map (p := fun T : RawTree n => 0 < rawTreeTotal n T ∧ rawTreeTotal n T < ∞) |
| (measurable_noiseTreeForget M n).aemeasurable |
| change ∀ᵐ T : RawTree n ∂(noiseCascadeLaw M n b ν : Measure (NoiseTree M n)).map |
| (noiseTreeForget M n), 0 < rawTreeTotal n T ∧ rawTreeTotal n T < ∞ |
| rw [noiseCascadeLaw_forget] |
| exact (rawCascade_total_moments n b hb).1 |
| have hproj := measurePreserving_snd (μ := (tensorGaussianLaw I degree (v 0) : Measure M)) |
| (ν := tensorCascadeLaw I degree n b (fun i => v (i + 1))) |
| have hg' := hp.quasiMeasurePreserving.ae (hproj.quasiMeasurePreserving.ae hg) |
| have ht' := hp.quasiMeasurePreserving.ae (hproj.quasiMeasurePreserving.ae ht) |
| filter_upwards [hg', ht'] with p hgp htp |
| intro U |
| let q := tensorFlatToCoordinates I degree n v p |
| have he : tensorFlatLog eig U c I degree amplitude n v p = |
| Real.log (∫ x, Real.exp (tensorLabeledEnergy eig U c I degree amplitude n q.1 |
| (tensorEnergyCoordinates U I degree amplitude n q.2) x) |
| ∂tensorLabeledReference N n (tensorEnergyCoordinates U I degree amplitude n q.2)) := by |
| apply congrArg Real.log |
| apply integral_congr_ae |
| exact ae_of_all _ fun x => congrArg Real.exp |
| (tensorLabeledEnergy_flat_eq eig U c I degree amplitude n v p x).symm |
| exact he.trans (tensorCoordinateLog_eq_noise eig U c I degree amplitude n q.1 q.2 hgp htp) |
|
|
| def tensorFlatToDisorder {N m k : ℕ} (I : Fin m → Finset (Fin N)) |
| (degree : Fin k → Fin m → ℕ) (n : ℕ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) |
| (p : (SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ)) : |
| SpecialOrthogonal N × ((SpinTensorIndex I degree → ℝ) × NoiseTree (SpinTensorIndex I degree → ℝ) n) := |
| (p.1.1, tensorFlatToNoise I degree n v (p.1.2, p.2)) |
|
|
| theorem tensorFlatToDisorder_measurePreserving {N m k : ℕ} |
| (μ : Measure (SpecialOrthogonal N)) [IsProbabilityMeasure μ] |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) |
| (n : ℕ) (b : ℕ → ℝ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) : |
| MeasurePreserving (tensorFlatToDisorder I degree n v) |
| ((μ.prod (labeledCascadeLaw n b : Measure (LabeledTree n))).prod gaussianCoordinates) |
| (μ.prod (tensorRootTreeLaw I degree n b (fun i => v (i + 1)) (v 0))) := by |
| have hp := ((MeasurePreserving.id μ).prod |
| (tensorFlatToNoise_measurePreserving I degree n b v)).comp |
| (measurePreserving_prodAssoc μ (labeledCascadeLaw n b : Measure (LabeledTree n)) gaussianCoordinates) |
| convert hp using 1 |
| rfl |
|
|
| /-- Exact almost-everywhere pressure identification with the actual |
| three-disorder model, suitable for transporting moments and variance. -/ |
| theorem tensorFlatPressure_eq_disorder_ae {N m k : ℕ} |
| (μ : Measure (SpecialOrthogonal N)) [IsProbabilityMeasure μ] (eig c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (b : ℕ → ℝ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) (hb : CascadeExponents n b) : |
| (fun p : (SpecialOrthogonal N × LabeledTree n) × (ℕ → ℝ) => |
| (N : ℝ)⁻¹ * tensorFlatLog eig (specialRotation p.1.1) c I degree amplitude n v (p.1.2, p.2)) =ᵐ[ |
| (μ.prod (labeledCascadeLaw n b : Measure (LabeledTree n))).prod gaussianCoordinates] |
| (tensorDisorderPressure eig c I degree amplitude n ∘ tensorFlatToDisorder I degree n v) := by |
| have hproj := (measurePreserving_snd (μ := μ) |
| (ν := (labeledCascadeLaw n b : Measure (LabeledTree n)).prod gaussianCoordinates)).comp |
| (measurePreserving_prodAssoc μ (labeledCascadeLaw n b : Measure (LabeledTree n)) gaussianCoordinates) |
| have he := hproj.quasiMeasurePreserving.ae (tensorFlatLog_eq_noise_ae eig c I degree amplitude n b v hb) |
| filter_upwards [he] with p hp |
| exact congrArg ((N : ℝ)⁻¹ * ·) (hp (specialRotation p.1.1)) |
|
|
| end InvariantIsing |
|
|
| end |
|
|
| end OAI |
|
|
