| 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 |
| |
