File size: 7,810 Bytes
b317718
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
import OAI.Probability.FreeIsing.Gaussian.TreeResponsePlanted
import OAI.Probability.FreeIsing.Gaussian.TreeResponsePosterior
import OAI.Probability.FreeIsing.Posterior.NormalizedPosteriorLimit

namespace OAI

noncomputable section

open MeasureTheory ProbabilityTheory Filter
open scoped Topology NNReal

namespace Problem367

open PlantedSymmetry GaussianTreeResponse GaussianTreeCovariance

lemma GaussianTreeResponse.measurable_observedRow {d : ℕ}
    (beta : ℝ) (D : Finset (TreeVertex d)) (r : TreeVertex d)
    (t : ℝ) (v : TreeVertex d) : Measurable (observedRow beta D r t v) := by
  classical
  unfold observedRow
  by_cases hv : v ∈ D
  · simp only [ite_eq_left hv]
    exact (measurable_response beta D r v).comp (measurable_observation t)
  · simp only [ite_eq_right hv]
    exact measurable_const

theorem HasFreeIsingLaw.observedRow_eq_posteriorResponse
    {d : ℕ} {beta : ℝ} {μ : Measure (TreeVertex d → IsingSpin)}
    (hμ : HasFreeIsingLaw (Real.tanh beta) μ)
    (D : Finset (TreeVertex d)) (hD : ConnectedFinset D) (r v : TreeVertex d)
    (hr : r ∈ D) (hv : v ∈ D) (t : ℝ≥0) :
    observedRow beta D r t v =ᵐ[μ.prod (gaussianNoiseLaw (TreeVertex d) t)]
      posteriorResponse (μ.prod (gaussianNoiseLaw (TreeVertex d) t))
        (MeasurableSpace.comap (finiteObservation D t) inferInstance)
        (fun p => spinSign (p.1 r)) (fun p => spinSign (p.1 v)) := by
  have h := hμ.finiteObservation_normalizedResponse D hD t ⟨r, hr⟩ ⟨v, hv⟩
  filter_upwards [h] with p hp
  simpa only [observedRow, ite_eq_left hv, posteriorResponse, posteriorCovariance] using hp.symm

theorem HasFreeIsingLaw.observedRow_tendsto_ae
    {d : ℕ} {beta : ℝ} {μ : Measure (TreeVertex d → IsingSpin)}
    (hμ : HasFreeIsingLaw (Real.tanh beta) μ) (hbeta : 0 ≤ beta)
    (D : ℕ → Finset (TreeVertex d)) (hD : Monotone D)
    (hconn : ∀ n, ConnectedFinset (D n)) (r : TreeVertex d)
    (hr : ∀ n, r ∈ D n) (hex : ∀ v, ∃ n, v ∈ D n) (t : ℝ≥0) (v : TreeVertex d) :
    ∀ᵐ p ∂μ.prod (gaussianNoiseLaw (TreeVertex d) t),
      Tendsto (fun n => observedRow beta (D n) r t v p) atTop
        (𝓝 (gaussianPosteriorResponse μ t r v p)) := by
  have heq (n : ℕ) : ∀ᵐ p ∂μ.prod (gaussianNoiseLaw (TreeVertex d) t),
      v ∈ D n → observedRow beta (D n) r t v p =
        posteriorResponse (μ.prod (gaussianNoiseLaw (TreeVertex d) t))
          (MeasurableSpace.comap (finiteObservation (D n) t) inferInstance)
          (fun p => spinSign (p.1 r)) (fun p => spinSign (p.1 v)) p := by
    by_cases hv : v ∈ D n
    · exact (hμ.observedRow_eq_posteriorResponse (D n) (hconn n) r v (hr n) hv t).mono
        (fun p hp _ => hp)
    · exact Filter.Eventually.of_forall (fun _ hv' => (hv hv').elim)
  obtain ⟨N, hN⟩ := hex v
  have hmem : ∀ᶠ n in atTop, v ∈ D n :=
    eventually_atTop.2 ⟨N, fun n hn => hD hn hN⟩
  filter_upwards [ae_all_iff.mpr heq,    hμ.gaussian_posteriorResponse_tendsto_ae hbeta D hD hex t r v] with p hp hlim
  exact hlim.congr' (hmem.mono (fun n hn => (hp n hn).symm))

theorem HasFreeIsingLaw.observedRow_meanSquare
    {d : ℕ} {beta : ℝ} {μ : Measure (TreeVertex d → IsingSpin)}
    (hμ : HasFreeIsingLaw (Real.tanh beta) μ) (hbeta : 0 ≤ beta)
    (D : ℕ → Finset (TreeVertex d)) (hD : Monotone D)
    (hconn : ∀ n, ConnectedFinset (D n)) (r : TreeVertex d)
    (hr : ∀ n, r ∈ D n) (hex : ∀ v, ∃ n, v ∈ D n) (t : ℝ≥0) (v : TreeVertex d) :
    Tendsto (fun n => ∫ p,
      (observedRow beta (D n) r t v p - gaussianPosteriorResponse μ t r v p) ^ 2
      ∂μ.prod (gaussianNoiseLaw (TreeVertex d) t)) atTop (𝓝 0) := by
  apply (hμ.gaussian_posteriorResponse_meanSquare hbeta D hD hex t r v).congr'
  obtain ⟨N, hN⟩ := hex v
  filter_upwards [eventually_ge_atTop N] with n hn
  apply integral_congr_ae
  filter_upwards [hμ.observedRow_eq_posteriorResponse (D n) (hconn n) r v    (hr n) (hD hn hN) t] with p hp
  rw [hp]

theorem HasFreeIsingLaw.observedRow_full_meanSquare
    {d : ℕ} {beta : ℝ} {μ : Measure (TreeVertex d → IsingSpin)}
    (hμ : HasFreeIsingLaw (Real.tanh beta) μ) (hbeta : 0 ≤ beta)
    (D : ℕ → Finset (TreeVertex d)) (hD : Monotone D)
    (hconn : ∀ n, ConnectedFinset (D n)) (r : TreeVertex d)
    (hr : ∀ n, r ∈ D n) (hrnil : r.1 = [])
    (hex : ∀ v, ∃ n, v ∈ D n) {t : ℝ≥0} (ht : 0 < t)
    (hcrit : ((d - 1 : ℕ) : ℝ) * Real.tanh beta ^ 2 ≤ 1) :
    (∀ n, Summable (fun v => ∫ p,
      (observedRow beta (D n) r t v p - gaussianPosteriorResponse μ t r v p) ^ 2
        ∂μ.prod (gaussianNoiseLaw (TreeVertex d) t))) ∧
    Tendsto (fun n => ∑' v, ∫ p,
      (observedRow beta (D n) r t v p - gaussianPosteriorResponse μ t r v p) ^ 2
        ∂μ.prod (gaussianNoiseLaw (TreeVertex d) t)) atTop (𝓝 0) := by
  let : IsProbabilityMeasure μ := hμ.isProbabilityMeasure
  let P := μ.prod (gaussianNoiseLaw (TreeVertex d) t)
  let q := Real.tanh beta ^ 2 * gaussianContraction beta t
  let X := fun n v => observedRow beta (D n) r t v
  let Y := fun v => gaussianPosteriorResponse μ t r v
  have hq : 0 ≤ q := mul_nonneg (sq_nonneg _) (gaussianContraction_pos beta t).le
  have hqs : ((d - 1 : ℕ) : ℝ) * q < 1 := gaussian_radial_ratio_lt_one ht hcrit
  have hXm (n : ℕ) (v : TreeVertex d) : AEStronglyMeasurable (X n v) P :=
    (measurable_observedRow beta (D n) r t v).aestronglyMeasurable
  have hYm (v : TreeVertex d) : AEStronglyMeasurable (Y v) P :=
    ((stronglyMeasurable_posteriorResponse P (observationSigma (TreeVertex d) t)
      (fun p => spinSign (p.1 r)) (fun p => spinSign (p.1 v))).mono
        (observationSigma_le (TreeVertex d) t)).aestronglyMeasurable
  have hXi (n : ℕ) (v : TreeVertex d) : Integrable (fun p => X n v p ^ 2) P :=
    integrable_observedRow_sq μ hbeta t (hconn n) (hr n) hrnil v
  have hXb (n : ℕ) (v : TreeVertex d) : (∫ p, X n v p ^ 2 ∂P) ≤ q ^ v.1.length :=
    integral_observedRow_sq_le μ hbeta ht (hconn n) (hr n) hrnil v
  have hY (v : TreeVertex d) : Integrable (fun p => Y v p ^ 2) P ∧
      (∫ p, Y v p ^ 2 ∂P) ≤ q ^ v.1.length :=
    integrable_sq_and_integral_le_of_tendsto_ae P
      (fun n => hXm n v) (hYm v) (pow_nonneg hq _)
      (hμ.observedRow_tendsto_ae hbeta D hD hconn r hr hex t v)
      (Filter.Eventually.of_forall (fun n => ⟨hXi n v, hXb n v⟩))
  have hEi (n : ℕ) (v : TreeVertex d) :
      Integrable (fun p => (X n v p - Y v p) ^ 2) P := by
    exact (((memLp_two_iff_integrable_sq (hXm n v)).mpr (hXi n v)).sub
      ((memLp_two_iff_integrable_sq (hYm v)).mpr (hY v).1)).integrable_sq
  have hEb (n : ℕ) (v : TreeVertex d) :
      (∫ p, (X n v p - Y v p) ^ 2 ∂P) ≤ 4 * q ^ v.1.length := by
    have hle : (∫ p, (X n v p - Y v p) ^ 2 ∂P) ≤
        ∫ p, 2 * X n v p ^ 2 + 2 * Y v p ^ 2 ∂P := by
      apply integral_mono (hEi n v) (((hXi n v).const_mul 2).add ((hY v).1.const_mul 2))
      intro p
      change (X n v p - Y v p) ^ 2 ≤ 2 * X n v p ^ 2 + 2 * Y v p ^ 2
      nlinarith [sq_nonneg (X n v p + Y v p)]
    rw [integral_add ((hXi n v).const_mul 2) ((hY v).1.const_mul 2),
      integral_const_mul, integral_const_mul] at hle
    linarith [hXb n v, (hY v).2]
  have hs : Summable (fun v : TreeVertex d => 4 * q ^ v.1.length) :=
    (summable_geometric_radial d hq hqs).mul_left 4
  refine ⟨fun n => Summable.of_nonneg_of_le
    (fun v => integral_nonneg (fun p => sq_nonneg _)) (hEb n) hs, ?_⟩
  have hlim := tendsto_tsum_of_dominated_convergence hs
    (fun v => hμ.observedRow_meanSquare hbeta D hD hconn r hr hex t v)
    (Filter.Eventually.of_forall (fun n v => by
      rw [Real.norm_of_nonneg (integral_nonneg (fun p => sq_nonneg _))]
      exact hEb n v))
  simpa only [tsum_zero] using hlim

end Problem367

end

end OAI