File size: 5,582 Bytes
dd14c26 | 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 | import Mathlib
import OAI.Probability.LogConcave.OraclePrograms.Expression
import OAI.Probability.LogConcave.OraclePrograms.SeedProgram
namespace OAI
section
noncomputable section
namespace LogConcaveSampling.OracleCompiler
open MeasureTheory Program Expression
open scoped Classical BigOperators
variable {d : ℕ}
structure ReservedProgram (d : ℕ) where
slots : ℕ
calls : ℕ
pre : Program (Point d × (Fin slots → Point d)) d calls (Point d)
shift : Fin slots → ℝ
reserve : ℝ
namespace ReservedProgram
def full (S : ReservedProgram d) : SeedProgram d where
slots := S.slots+1
calls := S.calls
program := (S.pre.seedMap (fun z : Point d × (Fin (S.slots+1) → Point d) =>
(z.1,fun i => z.2 (Fin.castAdd 1 i))) (by fun_prop)).map
(fun z => z.2+S.reserve • z.1.2 (Fin.natAdd S.slots 0)) (by fun_prop)
shift := Fin.append S.shift (fun _ => 0)
lemma full_run (S : ReservedProgram d) (V : Point d → ℝ)
(x : Point d) (g : Fin (S.slots+1) → Point d) :
S.full.program.run V (x,g)=
S.pre.run V (x,fun i => g (Fin.castAdd 1 i))+S.reserve • g (Fin.natAdd S.slots 0) := by
change ((S.pre.seedMap (fun z : Point d × (Fin (S.slots+1) → Point d) =>
(z.1,fun i => z.2 (Fin.castAdd 1 i))) (by fun_prop)).map
(fun z => z.2+S.reserve • z.1.2 (Fin.natAdd S.slots 0)) (by fun_prop)).run V (x,g)=_
rw [Program.map_run,Program.seedMap_run]
def extraShift (S : ReservedProgram d) (c : ℝ) : Fin (S.slots+1) → ℝ :=
Fin.append S.shift (fun _ => c)
lemma full_equivariant (S : ReservedProgram d) (r c : ℝ) (Δ : Point d)
(hS : S.pre.Equivariant (moveSeed (fun x => x+r • Δ) S.shift Δ) (fun y => y-Δ)) :
S.full.program.Equivariant
(moveSeed (fun x => x+r • Δ) (S.extraShift c) Δ)
(fun y => y-Δ+(S.reserve*c) • Δ) := by
dsimp only [full]
apply Program.Equivariant.map
(hS.seedMap _ (by fun_prop) _ ?_) _ (by fun_prop) _
· intro z y
simp only [moveSeed,extraShift,shiftSlots,Fin.append_right]
simp only [smul_add,smul_smul]
abel
· intro z
apply Prod.ext
· rfl
· funext i
simp [moveSeed,extraShift,shiftSlots]
lemma extraShift_energy (S : ReservedProgram d) (c : ℝ) :
(∑i,S.extraShift c i^2)=(∑i,S.shift i^2)+c^2 := by
simp [extraShift,Fin.sum_univ_add]
end ReservedProgram
def sampleParent (E : Expression (Point d × Point d) d) (v : Fin E.slots → ℝ)
(T η : ℝ) : ReservedProgram d where
slots := 1+E.slots
calls := E.calls
pre := E.compile.seedMap (fun z : Point d × (Fin (1+E.slots) → Point d) =>
((z.1,z.2 (Fin.castAdd E.slots 0)),fun i => z.2 (Fin.natAdd 1 i))) (by fun_prop)
shift := Fin.append (fun _ => -T) v
reserve := η/2
lemma sampleParent_run (E : Expression (Point d × Point d) d) (v : Fin E.slots → ℝ)
(T η : ℝ) (V : Point d → ℝ) (x : Point d) (g : Fin (1+E.slots) → Point d) :
(sampleParent E v T η).pre.run V (x,g)=
E.eval V (x,g (Fin.castAdd E.slots 0)) (fun i => g (Fin.natAdd 1 i)) := by
change (E.compile.seedMap (fun z : Point d × (Fin (1+E.slots) → Point d) =>
((z.1,z.2 (Fin.castAdd E.slots 0)),fun i => z.2 (Fin.natAdd 1 i))) (by fun_prop)).run V (x,g)=_
rw [Program.seedMap_run,Expression.compile_run]
def meanParent (S : SeedProgram d)
(E : Expression (Point d × (Point d × Point d)) d)
(u : Fin S.slots → ℝ) (v : Fin E.slots → ℝ) (T : ℝ) : SeedProgram d where
slots := S.slots+(1+E.slots)
calls := S.calls+E.calls
program :=
(S.program.seedMap (fun z : Point d × (Fin (S.slots+(1+E.slots)) → Point d) =>
(z.1,leftBlock z.2)) (by unfold leftBlock; fun_prop)).seq
(E.compile.seedMap (fun z =>
((z.1.1,(T • z.2,middleBlock z.1.2 0)),rightBlock z.1.2)) (by unfold middleBlock rightBlock; fun_prop))
shift := Fin.append u (Fin.append (fun _ => 0) v)
lemma meanParent_run (S : SeedProgram d)
(E : Expression (Point d × (Point d × Point d)) d)
(u : Fin S.slots → ℝ) (v : Fin E.slots → ℝ) (T : ℝ)
(V : Point d → ℝ) (x : Point d) (g : Fin (S.slots+(1+E.slots)) → Point d) :
(meanParent S E u v T).program.run V (x,g)=
E.eval V (x,(T • S.program.run V (x,leftBlock g),middleBlock g 0)) (rightBlock g) := by
change ((S.program.seedMap _ _).seq (E.compile.seedMap _ _)).run V (x,g)=_
rw [Program.seq_run,Program.seedMap_run,Program.seedMap_run,Expression.compile_run]
lemma meanParent_shift_energy (S : SeedProgram d)
(E : Expression (Point d × (Point d × Point d)) d)
(u : Fin S.slots → ℝ) (v : Fin E.slots → ℝ) (T : ℝ) :
(∑i,(meanParent S E u v T).shift i^2)=(∑i,u i^2)+(∑i,v i^2) := by
change (∑i : Fin (S.slots+(1+E.slots)), (Fin.append u (Fin.append (fun _ => 0) v)) i^2)=_
simp [Fin.sum_univ_add]
lemma sampleParent_shift_energy (E : Expression (Point d × Point d) d)
(v : Fin E.slots → ℝ) (T η : ℝ) :
(∑i,(sampleParent E v T η).shift i^2)=T^2+(∑i,v i^2) := by
change (∑i : Fin (1+E.slots), (Fin.append (fun _ => -T) v) i^2)=_
simp [Fin.sum_univ_add]
lemma mean_anchor_shift_identity {T R : ℝ} (hT : T≠0) (he : T^2+R^2=1)
(y Δ : Point d) :
T • (y-Δ+(R/(2*T)*(-2*R/T)) • Δ)=T • y-T⁻¹ • Δ := by
have ha : T*(-1+R/(2*T)*(-2*R/T))=-T⁻¹ := by
field_simp
nlinarith
simp only [smul_add,smul_sub,smul_smul]
have hb : T*(R/(2*T)*(-2*R/T))-T=-T⁻¹ := by nlinarith [ha]
calc
_ = T • y+(T*(R/(2*T)*(-2*R/T))-T) • Δ := by module
_ = _ := by rw [hb]; module
end LogConcaveSampling.OracleCompiler
end
end
end OAI
|