File size: 9,624 Bytes
a2ee19a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
import Mathlib
import OAI.Probability.Perceptron.Variational.LabelValue
import OAI.Probability.Perceptron.Control.StepControl

namespace OAI

noncomputable section
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology ENNReal NNReal BigOperators BoundedContinuousFunction
namespace SphericalPerceptronFreeEnergy

lemma oneDim_inner (v : EuclideanSpace ℝ (Fin 1)) :
    inner ℝ (WithLp.toLp 2 (fun _ : Fin 1 => (1:ℝ))) v=v 0 := by
  simp [PiLp.inner_apply]

lemma oneDim_gaussian_average (s : ℝ≥0) (f : ℝ →ᵇ ℝ) (a : ℝ) :
    (∫ v : EuclideanSpace ℝ (Fin 1), f (a+Real.sqrt s*v 0)
      ∂stdGaussian (EuclideanSpace ℝ (Fin 1)))=gaussianAverage s f a := by
  rw [gaussianAverage_scaling]
  have h : (∫ z, f (a+Real.sqrt s*z) ∂((stdGaussian (EuclideanSpace ℝ (Fin 1))).map
      (fun v => v 0)))=∫ v : EuclideanSpace ℝ (Fin 1), f (a+Real.sqrt s*v 0)
        ∂stdGaussian (EuclideanSpace ℝ (Fin 1)) :=
    integral_map (show Measurable (fun v : EuclideanSpace ℝ (Fin 1) => v 0) from by fun_prop).aemeasurable
      (show Measurable (fun z : ℝ => f (a+Real.sqrt s*z)) from by fun_prop).aestronglyMeasurable
  rw [stdGaussian_coordinate_law] at h
  exact h.symm

lemma oneDim_gaussian_entropic (s b : ℝ≥0) (f : ℝ →ᵇ ℝ) (x : EuclideanSpace ℝ (Fin 1)) :
    gaussianLinearEntropic (stdGaussian (EuclideanSpace ℝ (Fin 1))) b
      (diagonalMark (fun _ => Real.sqrt s)) (fun v => f (v 0)) x=heatLog s b f (x 0) := by
  have hX : ∀ a : ℝ, Integrable
      (fun v : EuclideanSpace ℝ (Fin 1) => Real.exp (a*f (x 0+Real.sqrt s*v 0)))
      (stdGaussian (EuclideanSpace ℝ (Fin 1))) := fun a =>
    boundedContinuousFunction_integrable_comp (expBCF a f) (by fun_prop)
  change entropicMean (stdGaussian (EuclideanSpace ℝ (Fin 1))) b
    (fun v => f (x 0+Real.sqrt s*v 0))=heatLog s b f (x 0)
  by_cases hb : b=0
  · subst b
    rw [NNReal.coe_zero,entropicMean_zero _ hX,heatLog,ite_eq_left rfl,oneDim_gaussian_average]
  · rw [entropicMean_eq_div _ hX (by exact_mod_cast hb),heatLog,ite_eq_right hb]
    unfold cgf mgf
    change Real.log (∫ v : EuclideanSpace ℝ (Fin 1), expBCF b f (x 0+Real.sqrt s*v 0)
      ∂stdGaussian (EuclideanSpace ℝ (Fin 1)))/(b:ℝ)=_
    rw [oneDim_gaussian_average]
    ring

lemma linearCascadeWord_congr {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (A B : ℕ→E→L[ℝ] E) (k : ℕ) (z : Fin k→ℝ) (h : ∀ j<k,A j=B j) :
    linearCascadeWord A k z=linearCascadeWord B k z := by
  induction k with
  | zero => rfl
  | succ k ih =>
    simp only [linearCascadeWord]
    rw [h k (Nat.lt_succ_self k),ih (fun i => z i.succ) (fun j hj => h j (Nat.lt_succ_of_lt hj))]

lemma profileGaussianStep_first {k : ℕ} (q : Fin (k+2)→Time) :
    profileGaussianStep (fun l (_ : Fin 1) => (q l:ℝ)) k=
      fun _ => Real.sqrt (timeSpan (q 0) (q 1)) := by
  funext i
  simp only [profileGaussianStep,dite_eq_left (Nat.lt_succ_self k)]
  have h0 : (⟨k+1-k-1,by omega⟩ : Fin (k+2))=0 := by ext; simp
  have h1 : (⟨k+1-k,by omega⟩ : Fin (k+2))=1 := by ext; simp
  rw [h0,h1]
  simp only [timeSpan,Real.coe_toNNReal']
  by_cases h : 0≤(q 1:ℝ)-q 0
  · rw [max_eq_left h]
  · have hn : (q 1:ℝ)-q 0≤0 := by linarith
    rw [max_eq_right hn,Real.sqrt_eq_zero_of_nonpos hn,Real.sqrt_zero]

lemma profileGaussianStep_tail {k : ℕ} (q : Fin (k+2)→Time) {j : ℕ} (hj : j<k) :
    profileGaussianStep (fun l (_ : Fin 1) => (q l:ℝ)) j=
      profileGaussianStep (fun l (_ : Fin 1) => (q l.succ:ℝ)) j := by
  funext i
  simp only [profileGaussianStep,dite_eq_left hj,dite_eq_left (Nat.lt_succ_of_lt hj)]
  have ha : (⟨k+1-j,by omega⟩ : Fin (k+2))=(⟨k-j,by omega⟩ : Fin (k+1)).succ := by
    ext; simp only [Fin.val_succ]; omega
  have hb : (⟨k+1-j-1,by omega⟩ : Fin (k+2))=(⟨k-j-1,by omega⟩ : Fin (k+1)).succ := by
    ext; simp only [Fin.val_succ]; omega
  rw [ha,hb]

lemma oneDim_profile_backward (g : Jet3) (k : ℕ) (q : Fin (k+1)→Time)
    (z : Fin k→ℝ≥0) (x : EuclideanSpace ℝ (Fin 1)) :
    gaussianLinearBackward (stdGaussian (EuclideanSpace ℝ (Fin 1)))
      (linearCascadeWord (fun j => diagonalMark (profileGaussianStep (fun l (_ : Fin 1) => (q l:ℝ)) j))
        k (fun i => z i)) (fun v => g.f (v 0)) x=(finiteStepControlJet g k q z).f (x 0) := by
  induction k generalizing x with
  | zero => rfl
  | succ k ih =>
    simp only [linearCascadeWord,gaussianLinearBackward,finiteStepControlJet]
    rw [profileGaussianStep_first]
    have hw := linearCascadeWord_congr
      (fun j => diagonalMark (profileGaussianStep (fun l (_ : Fin 1) => (q l:ℝ)) j))
      (fun j => diagonalMark (profileGaussianStep (fun l (_ : Fin 1) => (q l.succ:ℝ)) j))
      k (fun i => (z i.succ:ℝ)) (fun j hj => congrArg diagonalMark (profileGaussianStep_tail q hj))
    rw [hw]
    have hf := funext (ih (fun i => q i.succ) (fun i => z i.succ))
    rw [hf,oneDim_gaussian_entropic,Jet3.heatLog_f]
    change _=heatLog _ _ _ _
    rfl

lemma HeatChain.prepend {m : Trial} {g h j : Jet3} {a b c : Time}
    (H : HeatChain m g b c h) (J : HeatChain m h a b j) : HeatChain m g a c j := by
  induction J with
  | nil => exact H
  | cons d hat htb hm tail ih =>
    exact HeatChain.cons d hat (htb.trans H.left_le_right) hm (ih H)

lemma weightedStepTrial_controlValue_core (k : ℕ) (w : Fin (k+1)→ℝ) (q : Fin (k+1)→Time)
    (hw : ∀ i, 0≤w i) (hw1 : ∑ i,w i=1) (hq : Monotone q) (g : Jet3)
    (P : Measure BrownianPath) [IsProbabilityMeasure P] (hB : IsBrownianReal brownianEval P) :
    controlValue P g.f (weightedStepTrial w q hw hw1)=
      ((finiteStepControlJet (g.heatLog (timeSpan (q (Fin.last k)) 1) 1) k q
        (weightedControlCoefficient k w hw)).heatLog (timeSpan 0 (q 0)) 0).f 0 := by
  let m := leftWeightedStepTrial w q hw hw1
  have ht : HeatChain m g (q (Fin.last k)) 1 (g.heatLog (timeSpan (q (Fin.last k)) 1) 1) := by
    rcases lt_or_eq_of_le (show q (Fin.last k)≤1 from le_top) with hl|he
    · apply HeatChain.cons 1 hl le_rfl _ (HeatChain.nil 1)
      intro r hr
      change (∑ i, if q i<r then w i else 0)=(1:ℝ)
      have hqr i : q i<r := (hq (Fin.le_last i)).trans_lt hr.1
      simp only [hqr,ite_true,hw1]
    · rw [he]
      simp only [timeSpan,sub_self,Real.toNNReal_zero,Jet3.heatLog_zero_time]
      exact HeatChain.nil 1
  have hm := finiteStepControlJet_chain (g.heatLog (timeSpan (q (Fin.last k)) 1) 1)
    m k q (weightedControlCoefficient k w hw) hq
    (fun i r hr => leftWeightedStepTrial_interval k w q hw hw1 hq i hr)
  have hm' := ht.prepend hm
  have H : HeatChain m g 0 1 ((finiteStepControlJet (g.heatLog (timeSpan (q (Fin.last k)) 1) 1)
      k q (weightedControlCoefficient k w hw)).heatLog (timeSpan 0 (q 0)) 0) := by
    rcases lt_or_eq_of_le (show (0:Time)≤q 0 from bot_le) with hl|he
    · apply HeatChain.cons 0 hl (show q 0≤1 from le_top) _ hm'
      intro r hr
      change (∑ i, if q i<r then w i else 0)=(0:ℝ)
      have hqr i : ¬ q i<r := not_lt_of_ge (hr.2.trans (hq (Fin.zero_le i)))
      simp only [hqr,ite_false,Finset.sum_const_zero]
    · rw [←he] at hm' ⊢
      simpa only [timeSpan,sub_self,Real.toNNReal_zero,Jet3.heatLog_zero_time] using hm'
  have he := leftWeightedStepTrial_ae w q hw hw1
  have hv := controlValue_trial_abs_sub_le P g.f (weightedStepTrial w q hw hw1) m ‖g.d1‖₊ g.lipschitz
  have hz : (∫ t, |weightedStepTrial w q hw hw1 t-m t| ∂timeLaw)=0 := by
    apply integral_eq_zero_of_ae
    filter_upwards [he] with t ht
    simp only [m,ht,sub_self,abs_zero,Pi.zero_apply]
  rw [hz,mul_zero] at hv
  rw [sub_eq_zero.mp (abs_eq_zero.mp (le_antisymm hv (abs_nonneg _)))]
  exact H.controlValue_eq P hB

theorem labelProfileValue_control (k : ℕ) (w : Fin (k+1)→ℝ) (q : Fin (k+1)→Time)
    (hw : ∀ i, 0≤w i) (hw1 : ∑ i,w i=1) (hq : Monotone q) (g : Jet3)
    (P : Measure BrownianPath) [IsProbabilityMeasure P] (hB : IsBrownianReal brownianEval P) :
    labelProfileValue k (stepCumulative w) (fun i => (q i:ℝ)) (q (Fin.last k)).prop.2 g=
      controlValue P g.f (weightedStepTrial w q hw hw1) := by
  rw [weightedStepTrial_controlValue_core k w q hw hw1 hq g P hB]
  have hend : (⟨1-(q (Fin.last k):ℝ),sub_nonneg.mpr (q (Fin.last k)).prop.2⟩ : ℝ≥0)=
      timeSpan (q (Fin.last k)) 1 := by
    apply Subtype.ext
    change 1-(q (Fin.last k):ℝ)=(timeSpan (q (Fin.last k)) 1:ℝ)
    exact (timeSpan_coe (show q (Fin.last k)≤1 from le_top)).symm
  have hstart : (timeSpan 0 (q 0):ℝ)=(q 0:ℝ) := by
    rw [timeSpan_coe (show (0:Time)≤q 0 from bot_le)]; simp
  have hterm : labelProfileTerminal g (timeSpan (q (Fin.last k)) 1)=
      fun v : EuclideanSpace ℝ (Fin 1) => (g.heatLog (timeSpan (q (Fin.last k)) 1) 1).f (v 0) := by
    funext v
    rw [labelProfileTerminal,oneDim_inner,Jet3.heatLog_f]
    rfl
  have hc : stepCumulative w=fun i => (weightedControlCoefficient k w hw i:ℝ) := rfl
  unfold labelProfileValue
  rw [hend,hterm,hc]
  simp_rw [oneDim_profile_backward]
  simp only [diagonalMark_apply,profileGaussianRoot]
  rw [Jet3.heatLog_f]
  change (∫ x : EuclideanSpace ℝ (Fin 1),
    (finiteStepControlJet (g.heatLog (timeSpan (q (Fin.last k)) 1) 1) k q
      (weightedControlCoefficient k w hw)).f (Real.sqrt (q 0:ℝ)*x 0)
      ∂stdGaussian (EuclideanSpace ℝ (Fin 1)))=heatLog (timeSpan 0 (q 0)) 0 _ 0
  rw [heatLog,ite_eq_left rfl]
  simpa only [hstart,zero_add] using oneDim_gaussian_average (timeSpan 0 (q 0))
    (finiteStepControlJet (g.heatLog (timeSpan (q (Fin.last k)) 1) 1) k q
      (weightedControlCoefficient k w hw)).f 0

end SphericalPerceptronFreeEnergy
end

end OAI