File size: 8,380 Bytes
f61e547
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
import OAI.Probability.FreeIsing.Estimates.MessageFunction
import OAI.Probability.FreeIsing.Ising.ConditionalCopyBounds

namespace OAI

noncomputable section

open MeasureTheory ProbabilityTheory Set
open scoped NNReal

namespace Problem367

theorem abs_artanh_le_two_mul_of_abs_le_half {x : ℝ} (hx : |x| ≤ 1 / 2) :
    |Real.artanh x| ≤ 2 * |x| := by
  have hd (z : ℝ) (hz : z ∈ Icc (-1 / 2 : ℝ) (1 / 2)) :
      HasDerivWithinAt Real.artanh (1 / (1 - z ^ 2)) (Icc (-1 / 2) (1 / 2)) z :=
    (hasDerivAt_artanh_interval (by constructor <;> linarith [hz.1, hz.2])).hasDerivWithinAt
  have hb (z : ℝ) (hz : z ∈ Icc (-1 / 2 : ℝ) (1 / 2)) :
      ‖1 / (1 - z ^ 2)‖ ≤ (2 : ℝ) := by
    have hsq : z ^ 2 ≤ 1 / 4 := by
      nlinarith [mul_nonneg (by linarith [hz.1] : 0 ≤ z + 1 / 2)
        (by linarith [hz.2] : 0 ≤ 1 / 2 - z)]
    have hden : 0 < 1 - z ^ 2 := by linarith
    rw [Real.norm_eq_abs, abs_of_nonneg (by positivity : 0 ≤ 1 / (1 - z ^ 2))]
    exact (div_le_iff₀ hden).mpr (by linarith)
  have h := Convex.norm_image_sub_le_of_norm_hasDerivWithin_le hd hb (convex_Icc _ _)
    (by norm_num : (0 : ℝ) ∈ Icc (-1 / 2 : ℝ) (1 / 2))
    (show x ∈ Icc (-1 / 2 : ℝ) (1 / 2) by
      constructor <;> linarith [(abs_le.mp hx).1, (abs_le.mp hx).2])
  simpa only [Real.artanh_zero, sub_zero, Real.norm_eq_abs] using h

theorem artanh_sub_sq_le_information {x y K : ℝ}
    (hK : |Real.artanh x - Real.artanh y| ≤ K) :
    (Real.artanh x - Real.artanh y) ^ 2 ≤ (8 + 4 * K ^ 2) * (x ^ 2 + y ^ 2) := by
  have hK0 : 0 ≤ K := (abs_nonneg _).trans hK
  have hdiff : (Real.artanh x - Real.artanh y) ^ 2 ≤ K ^ 2 := by
    simpa only [sq_abs] using (pow_le_pow_left₀ (abs_nonneg _) hK 2)
  by_cases hx : |x| ≤ 1 / 2
  · by_cases hy : |y| ≤ 1 / 2
    · have hax : (Real.artanh x) ^ 2 ≤ 4 * x ^ 2 := by
        have h := mul_self_le_mul_self (abs_nonneg _) (abs_artanh_le_two_mul_of_abs_le_half hx)
        nlinarith only [h, sq_abs (Real.artanh x), sq_abs x]
      have hay : (Real.artanh y) ^ 2 ≤ 4 * y ^ 2 := by
        have h := mul_self_le_mul_self (abs_nonneg _) (abs_artanh_le_two_mul_of_abs_le_half hy)
        nlinarith only [h, sq_abs (Real.artanh y), sq_abs y]
      have hsum : 0 ≤ 4 * K ^ 2 * (x ^ 2 + y ^ 2) := by positivity
      nlinarith [sq_nonneg (Real.artanh x + Real.artanh y)]
    · have hy' : 1 / 2 ≤ |y| := (lt_of_not_ge hy).le
      have hy2 := mul_self_le_mul_self (by norm_num : (0 : ℝ) ≤ 1 / 2) hy'
      have hmul := mul_le_mul_of_nonneg_left hy2 (sq_nonneg K)
      nlinarith [sq_abs y, sq_nonneg x, sq_nonneg y, mul_nonneg (sq_nonneg K) (sq_nonneg x)]
  · have hx' : 1 / 2 ≤ |x| := (lt_of_not_ge hx).le
    have hx2 := mul_self_le_mul_self (by norm_num : (0 : ℝ) ≤ 1 / 2) hx'
    have hmul := mul_le_mul_of_nonneg_left hx2 (sq_nonneg K)
    nlinarith [sq_abs x, sq_nonneg x, sq_nonneg y, mul_nonneg (sq_nonneg K) (sq_nonneg y)]

namespace IsingConditionalCopyBounds

open IsingObservationInnovation

def posteriorInformation {d : ℕ} (beta : ℝ) (μ : Measure (TreeVertex d → IsingSpin))
    (v : TreeVertex d) (t : ℝ≥0) : ℝ :=
  ∫ x, (IsingObservationInnovation.posterior beta v t x) ^ 2 ∂observationLaw μ

theorem posteriorInformation_eq_gaussian
    {d : ℕ} {beta : ℝ} {μ : Measure (TreeVertex d → IsingSpin)}
    (hμ : HasFreeIsingLaw (Real.tanh beta) μ) (t : ℝ≥0) (v : TreeVertex d) :
    posteriorInformation beta μ v t =
      ∫ p, (PlantedSymmetry.posteriorMagnetization (μ.prod (PlantedSymmetry.gaussianNoiseLaw
        (TreeVertex d) t)) t v p) ^ 2 ∂μ.prod
          (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t) := by
  let : IsProbabilityMeasure μ := hμ.isProbabilityMeasure
  have heval := hasLaw_observationLaw_eval μ t
  have hobs : HasLaw (PlantedSymmetry.observation t)
      ((μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)).map
        (PlantedSymmetry.observation t))
      (μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t)) :=
    ⟨(PlantedSymmetry.measurable_observation t).aemeasurable, rfl⟩
  have hsame := (heval.identDistrib hobs).comp
    ((measurable_infiniteGibbsSpinMean beta v).pow_const 2)
  calc
    _ = ∫ p, (infiniteGibbsSpinMean beta v (PlantedSymmetry.observation t p)) ^ 2
        ∂μ.prod (PlantedSymmetry.gaussianNoiseLaw (TreeVertex d) t) := hsame.integral_eq
    _ = _ := integral_congr_ae
      ((hμ.infiniteGibbsSpinMean_eq_posterior t v).fun_comp (fun z : ℝ => z ^ 2))

theorem fieldDifference_secondMoment_le_information
    {d : ℕ} {beta : ℝ} {μ : Measure (TreeVertex d → IsingSpin)}
    {rho : Measure (Paths d)} [IsProbabilityMeasure rho]
    {eta : Kernel (Paths d) (Paths d)} [IsMarkovKernel eta]
    (hμ : HasFreeIsingLaw (Real.tanh beta) μ) (hbeta : 0 ≤ beta)
    (hjoint : rho ⊗ₘ eta = graphLaw beta μ) (t : ℝ≥0) (v : TreeVertex d) :
    (∫ q, (fieldDifference beta v t q) ^ 2 ∂rho ⊗ₘ (eta ×ₖ eta)) ≤
      2 * (8 + 4 * (2 * (t : ℝ) + 2 * (d : ℝ) * beta) ^ 2) *
        posteriorInformation beta μ v t := by
  let : IsProbabilityMeasure μ := hμ.isProbabilityMeasure
  let : IsProbabilityMeasure (labelMeasure d) := by unfold labelMeasure; infer_instance
  let : IsProbabilityMeasure (observationLaw μ) := by
    unfold observationLaw
    infer_instance
  let m : Paths d → ℝ := IsingObservationInnovation.posterior beta v t
  let C : ℝ := 8 + 4 * (2 * (t : ℝ) + 2 * (d : ℝ) * beta) ^ 2
  have hm : Measurable m :=
    (((posterior_progressive beta v).stronglyAdapted t).mono ((filtration d).le t)).measurable
  have hmLp : MemLp m 2 (observationLaw μ) :=
    MemLp.of_bound hm.aestronglyMeasurable 1
      (Filter.Eventually.of_forall (fun x => posterior_norm_le_one beta v t x))
  obtain ⟨hl, hr⟩ := measurePreserving_observation_copies hjoint
  have hml := hmLp.comp_measurePreserving hl
  have hmr := hmLp.comp_measurePreserving hr
  have hdiff := (fieldDifference_secondMoment_bounds hμ hbeta hjoint t v).1
  have hlint := hl.hasLaw.integral_comp (f := fun x => (m x) ^ 2)
    (hm.pow_const 2).aestronglyMeasurable
  have hrint := hr.hasLaw.integral_comp (f := fun x => (m x) ^ 2)
    (hm.pow_const 2).aestronglyMeasurable
  simp only [Function.comp_def] at hlint hrint
  calc
    (∫ q, (fieldDifference beta v t q) ^ 2 ∂rho ⊗ₘ (eta ×ₖ eta)) ≤
        ∫ q : CopySpace d, C * ((m q.2.1) ^ 2 + (m q.2.2) ^ 2)
          ∂rho ⊗ₘ (eta ×ₖ eta) := by
      apply integral_mono_ae hdiff.integrable_sq
        ((hml.integrable_sq.add hmr.integrable_sq).const_mul C)
      filter_upwards [ae_fieldDifference_bound hμ hbeta hjoint t v] with q hq
      exact artanh_sub_sq_le_information hq
    _ = C * ((∫ q : CopySpace d, (m q.2.1) ^ 2 ∂rho ⊗ₘ (eta ×ₖ eta)) +
          ∫ q : CopySpace d, (m q.2.2) ^ 2 ∂rho ⊗ₘ (eta ×ₖ eta)) := by
      rw [integral_const_mul]
      congr 1
      exact integral_add hml.integrable_sq hmr.integrable_sq
    _ = 2 * (8 + 4 * (2 * (t : ℝ) + 2 * (d : ℝ) * beta) ^ 2) *
        posteriorInformation beta μ v t := by
      rw [hlint, hrint]
      change C * (posteriorInformation beta μ v t + posteriorInformation beta μ v t) = _
      dsimp [C]
      ring

theorem fieldDifference_secondMoment_le_horizon_information
    {d : ℕ} {beta : ℝ} {μ : Measure (TreeVertex d → IsingSpin)}
    {rho : Measure (Paths d)} [IsProbabilityMeasure rho]
    {eta : Kernel (Paths d) (Paths d)} [IsMarkovKernel eta]
    (hμ : HasFreeIsingLaw (Real.tanh beta) μ) (hbeta : 0 ≤ beta)
    (hjoint : rho ⊗ₘ eta = graphLaw beta μ) {T t : ℝ≥0} (ht : t ≤ T)
    (v : TreeVertex d) :
    (∫ q, (fieldDifference beta v t q) ^ 2 ∂rho ⊗ₘ (eta ×ₖ eta)) ≤
      2 * (8 + 4 * (2 * (T : ℝ) + 2 * (d : ℝ) * beta) ^ 2) *
        posteriorInformation beta μ v t := by
  apply (fieldDifference_secondMoment_le_information hμ hbeta hjoint t v).trans
  have hI : 0 ≤ posteriorInformation beta μ v t := integral_nonneg (fun _ => sq_nonneg _)
  apply mul_le_mul_of_nonneg_right _ hI
  have htR : (t : ℝ) ≤ (T : ℝ) := ht
  have hK : 0 ≤ 2 * (t : ℝ) + 2 * (d : ℝ) * beta := by positivity
  have hsq := pow_le_pow_left₀ hK
    (show 2 * (t : ℝ) + 2 * (d : ℝ) * beta ≤ 2 * (T : ℝ) + 2 * (d : ℝ) * beta by linarith) 2
  linarith

end IsingConditionalCopyBounds

end Problem367

end

end OAI