File size: 8,046 Bytes
a89d282
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
164
165
166
167
168
169
170
171
import OAI.Probability.InvariantIsing.Spectral.MeasureInverseContinuity

namespace OAI

/-! Compact-support estimates for the general spectral transform. -/

noncomputable section
open MeasureTheory Filter Set
open scoped Topology Classical

namespace InvariantIsing

lemma integrable_spectralCoordinate (μ : Measure ℝ) [IsProbabilityMeasure μ]
    {l e : ℝ} (hμ : ∀ᵐ y ∂μ, y ∈ Icc l e) : Integrable (fun y => y) μ := by
  apply (integrable_const (|l| + |e|)).mono' measurable_id.aestronglyMeasurable
  filter_upwards [hμ] with y hy
  rw [Real.norm_eq_abs, abs_le]
  simp only [id_eq]
  constructor
  · linarith [neg_abs_le l, abs_nonneg e, hy.1]
  · linarith [le_abs_self e, abs_nonneg l, hy.2]

theorem measureR_bounds_all (μ : Measure ℝ) [IsProbabilityMeasure μ]
    {l e : ℝ} (hμ : ∀ᵐ y ∂μ, y ∈ Icc l e) (x : ℝ) :
    l ≤ measureR μ e x ∧ measureR μ e x ≤ e := by
  by_cases hx : 0 < x
  · exact measureR_bounds μ hμ hx
  · rw [measureR, ite_eq_right hx]
    constructor
    · simpa only [integral_const, probReal_univ, one_smul] using
        integral_mono_ae (integrable_const l) (integrable_spectralCoordinate μ hμ)
          (hμ.mono fun _ h => h.1)
    · simpa only [integral_const, probReal_univ, one_smul] using
        integral_mono_ae (integrable_spectralCoordinate μ hμ) (integrable_const e)
          (hμ.mono fun _ h => h.2)

theorem measureInverse_uncapped_small (μ : Measure ℝ) [IsProbabilityMeasure μ]
    {K e x : ℝ} (hK : 0 < K) (he : e ≤ K)
    (hμ : ∀ᵐ y ∂μ, y ∈ Icc (-K) e) (hx : 0 < x) (hsmall : 4 * K * x ≤ 1) :
    e < measureInverse μ e x ∧ measureResolvent μ (measureInverse μ e x) = x := by
  have htest : e < 1 / x - K := by
    have h := (le_div_iff₀ hx).mpr hsmall
    nlinarith
  have hl := le_measureResolvent μ hμ htest
  have hvalue : x ≤ measureResolvent μ (1 / x - K) := by
    simpa only [sub_neg_eq_add, sub_add_cancel, one_div_one_div] using hl
  have hex := exists_measureResolvent_solution μ (hμ.mono fun _ h => h.2) htest hx hvalue
  obtain ⟨b, hb, hsol⟩ := hex
  rw [measureInverse_eq_of_solution μ (hμ.mono fun _ h => h.2) hb hsol]
  exact ⟨hb, hsol⟩

theorem measureR_sub_mean_identity (μ : Measure ℝ) [IsProbabilityMeasure μ]
    {l e x : ℝ} (hμ : ∀ᵐ y ∂μ, y ∈ Icc l e) (hx : 0 < x)
    (hs : e < measureInverse μ e x ∧ measureResolvent μ (measureInverse μ e x) = x) :
    measureR μ e x - ∫ y, y ∂μ =
      ∫ y, (measureR μ e x - y) ^ 2 / (measureInverse μ e x - y) ∂μ := by
  let b := measureInverse μ e x
  have hi := integrable_spectralCoordinate μ hμ
  have hk : Integrable (fun y => 1 / (b - y)) μ :=
    integrable_resolventKernel μ (hμ.mono fun _ h => h.2) hs.1
  have ha : ∀ᵐ y ∂μ, (measureR μ e x - y) ^ 2 / (b - y) =
      (b - y) - 2 / x + (1 / x ^ 2) * (1 / (b - y)) := by
    filter_upwards [hμ] with y hy
    have hby : b - y ≠ 0 := by dsimp only [b]; linarith [hs.1, hy.2]
    simp only [measureR, ite_eq_left hx]
    change (b - 1 / x - y) ^ 2 / (b - y) = _
    field_simp [hx.ne', hby]
    ring
  have hibase : Integrable (fun y => b - y) μ := (integrable_const b).sub hi
  have hib : Integrable (fun y => b - y - 2 / x) μ :=
    hibase.sub (integrable_const (2 / x))
  have hir : Integrable (fun y => (1 / x ^ 2) * (1 / (b - y))) μ := hk.const_mul _
  have hsplit : (∫ y, b - y - 2 / x ∂μ) = b - (∫ y, y ∂μ) - 2 / x := by
    calc
      _ = (∫ y, b - y ∂μ) - (∫ _, 2 / x ∂μ) :=
        integral_sub hibase (integrable_const (2 / x))
      _ = _ := by
        rw [show (∫ y, b - y ∂μ) = (∫ _, b ∂μ) - (∫ y, y ∂μ) from
          integral_sub (integrable_const b) hi]
        simp
  rw [integral_congr_ae ha, integral_add hib hir, hsplit, integral_const_mul]
  change measureR μ e x - (∫ y, y ∂μ) =
    b - (∫ y, y ∂μ) - 2 / x + (1 / x ^ 2) * measureResolvent μ b
  rw [hs.2]
  simp only [measureR, ite_eq_left hx]
  change b - 1 / x - (∫ y, y ∂μ) = _
  field_simp
  ring

theorem measureR_sub_mean_bound (μ : Measure ℝ) [IsProbabilityMeasure μ]
    {K e x : ℝ} (hK : 0 < K) (he : e ≤ K)
    (hμ : ∀ᵐ y ∂μ, y ∈ Icc (-K) e) (hx : 0 < x) (hsmall : 4 * K * x ≤ 1) :
    0 ≤ measureR μ e x - ∫ y, y ∂μ ∧
      measureR μ e x - ∫ y, y ∂μ ≤ 8 * K ^ 2 * x := by
  let b := measureInverse μ e x
  let r := measureR μ e x
  have hs := measureInverse_uncapped_small μ hK he hμ hx hsmall
  have hr := measureR_bounds μ hμ hx
  have hbr : x * b = x * r + 1 := by
    dsimp only [b, r]
    simp only [measureR, ite_eq_left hx]
    field_simp
    ring
  have hb : ∀ᵐ y ∂μ, 0 ≤ (r - y) ^ 2 / (b - y) ∧
      (r - y) ^ 2 / (b - y) ≤ 8 * K ^ 2 * x := by
    filter_upwards [hμ] with y hy
    have hden : 0 < b - y := by dsimp only [b]; linarith [hs.1, hy.2]
    have hlo : -2 * K ≤ r - y := by dsimp only [r]; linarith [hr.1, hy.2]
    have hhi : r - y ≤ 2 * K := by dsimp only [r]; linarith [hr.2, hy.1]
    have hsq : (r - y) ^ 2 ≤ 4 * K ^ 2 := by
      nlinarith [mul_nonneg (sub_nonneg.mpr hlo) (sub_nonneg.mpr hhi)]
    have hinv : 1 / (b - y) ≤ 2 * x := by
      apply (div_le_iff₀ hden).mpr
      have := mul_le_mul_of_nonneg_left hlo hx.le
      nlinarith
    refine ⟨div_nonneg (sq_nonneg _) hden.le, ?_⟩
    calc
      (r - y) ^ 2 / (b - y) = (r - y) ^ 2 * (1 / (b - y)) := by ring
      _ ≤ (4 * K ^ 2) * (2 * x) := mul_le_mul hsq hinv (one_div_pos.mpr hden).le (by positivity)
      _ = 8 * K ^ 2 * x := by ring
  have hm : Measurable (fun y : ℝ => (r - y) ^ 2 / (b - y)) :=
    ((measurable_const.sub measurable_id).pow_const 2).div (measurable_const.sub measurable_id)
  have hi : Integrable (fun y => (r - y) ^ 2 / (b - y)) μ := by
    apply (integrable_const (8 * K ^ 2 * x)).mono' hm.aestronglyMeasurable
    filter_upwards [hb] with y hy
    simpa only [Real.norm_eq_abs, abs_of_nonneg hy.1] using hy.2
  rw [measureR_sub_mean_identity μ hμ hx hs]
  constructor
  · exact integral_nonneg_of_ae (hb.mono fun _ h => h.1)
  · have hu := integral_mono_ae hi (integrable_const (8 * K ^ 2 * x)) (hb.mono fun _ h => h.2)
    simpa only [integral_const, probReal_univ, one_smul] using hu

theorem continuousAt_measureR_zero (μ : Measure ℝ) [IsProbabilityMeasure μ]
    {K e : ℝ} (hK : 0 < K) (he : e ≤ K) (hμ : ∀ᵐ y ∂μ, y ∈ Icc (-K) e) :
    ContinuousAt (measureR μ e) 0 := by
  have herr : ∀ᶠ x : ℝ in 𝓝 0,
      ‖measureR μ e x - ∫ y, y ∂μ‖ ≤ 8 * K ^ 2 * |x| := by
    filter_upwards [Iio_mem_nhds (show (0 : ℝ) < 1 / (4 * K) by positivity)] with x hxsmall
    by_cases hx : 0 < x
    · have hsmall : 4 * K * x ≤ 1 := by
        have := (lt_div_iff₀ (show (0 : ℝ) < 4 * K by positivity)).mp hxsmall
        nlinarith
      have hb := measureR_sub_mean_bound μ hK he hμ hx hsmall
      simpa only [Real.norm_eq_abs, abs_of_nonneg hb.1, abs_of_pos hx] using hb.2
    · simp only [measureR, ite_eq_right hx, sub_self, norm_zero]
      positivity
  have ht : Tendsto (fun x : ℝ => 8 * K ^ 2 * |x|) (𝓝 0) (𝓝 0) := by
    simpa using (continuous_abs.tendsto (0 : ℝ)).const_mul (8 * K ^ 2)
  have hl := (tendsto_sub_nhds_zero_iff).mp (squeeze_zero_norm' herr ht)
  simpa only [ContinuousAt, measureR, lt_self_iff_false, ite_false] using hl

theorem continuous_measureR (μ : Measure ℝ) [IsProbabilityMeasure μ]
    {K e : ℝ} (hK : 0 < K) (he : e ≤ K) (hμ : ∀ᵐ y ∂μ, y ∈ Icc (-K) e) :
    Continuous (measureR μ e) := by
  apply continuous_iff_continuousAt.mpr
  intro x
  rcases lt_trichotomy x 0 with hx | hx | hx
  · have hc : ContinuousAt (fun _ : ℝ => ∫ y, y ∂μ) x := continuousAt_const
    apply hc.congr_of_eventuallyEq
    filter_upwards [Iio_mem_nhds hx] with y hy
    simp only [measureR, ite_eq_right (not_lt.mpr (show y < 0 from hy).le)]
  · subst x
    exact continuousAt_measureR_zero μ hK he hμ
  · exact continuousAt_measureR_pos μ (hμ.mono fun _ h => h.2) hx

end InvariantIsing

end

end OAI