openAI-math-dataset / lean /OAI /Probability /LogConcave /OraclePrograms /SampleParentEquivariant.lean
| import Mathlib | |
| import OAI.Probability.LogConcave.OraclePrograms.TerminalMeanProgram | |
| namespace OAI | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling.OracleCompiler | |
| open MeasureTheory Program Expression | |
| open scoped Classical BigOperators | |
| variable {d : ℕ} | |
| lemma sampleParent_equivariant (E : Expression (Point d × Point d) d) | |
| (v : Fin E.slots → ℝ) (r T η : ℝ) (Δ : Point d) | |
| (hE : E.compile.Equivariant | |
| (moveSeed (fun z => (z.1+r • Δ,z.2-T • Δ)) v Δ) (fun y => y-Δ)) : | |
| (sampleParent E v T η).pre.Equivariant | |
| (moveSeed (fun x => x+r • Δ) (sampleParent E v T η).shift Δ) (fun y => y-Δ) := by | |
| dsimp only [sampleParent] | |
| apply hE.seedMap _ (by fun_prop) _ | |
| intro z | |
| apply Prod.ext | |
| · simp [moveSeed,shiftSlots,Fin.append_left,sub_eq_add_neg] | |
| · funext i | |
| simp [moveSeed,shiftSlots,Fin.append_right] | |
| lemma meanParent_equivariant (S : SeedProgram d) | |
| (E : Expression (Point d × (Point d × Point d)) d) | |
| (u : Fin S.slots → ℝ) (v : Fin E.slots → ℝ) {r T : ℝ} (hT : T≠0) (Δ : Point d) | |
| (hS : S.program.Equivariant (moveSeed (fun x => x+r • Δ) u Δ) | |
| (fun y => y-(T⁻¹)^2 • Δ)) | |
| (hE : E.compile.Equivariant | |
| (moveSeed (fun z => (z.1+r • Δ,(z.2.1-T⁻¹ • Δ,z.2.2))) v Δ) id) : | |
| (meanParent S E u v T).program.Equivariant | |
| (moveSeed (fun x => x+r • Δ) (meanParent S E u v T).shift Δ) id := by | |
| dsimp only [meanParent] | |
| apply Program.Equivariant.seq (hS.seedMap _ (by unfold leftBlock; fun_prop) _ ?_) | |
| · apply hE.seedMap _ (by unfold middleBlock rightBlock; fun_prop) _ | |
| intro z | |
| apply Prod.ext | |
| · apply Prod.ext | |
| · rfl | |
| · apply Prod.ext | |
| · simp only [moveSeed,smul_sub,smul_smul] | |
| congr 1 | |
| congr 1 | |
| field_simp | |
| · simp [moveSeed,shiftSlots,middleBlock] | |
| · funext i | |
| simp [moveSeed,shiftSlots,rightBlock] | |
| · intro z | |
| apply Prod.ext | |
| · rfl | |
| · funext i | |
| simp [moveSeed,shiftSlots,leftBlock] | |
| lemma sampleParent_lipschitz (V : Point d → ℝ) (E : Expression (Point d × Point d) d) | |
| (v : Fin E.slots → ℝ) (T η K : ℝ) | |
| (hE : ∀x y z g,‖E.eval V (x,z) g-E.eval V (y,z) g‖≤K*‖x-y‖) : | |
| ∀x y g,‖(sampleParent E v T η).pre.run V (x,g)-(sampleParent E v T η).pre.run V (y,g)‖≤K*‖x-y‖ := by | |
| intro x y g | |
| rw [sampleParent_run E v T η V x g,sampleParent_run E v T η V y g] | |
| exact hE _ _ _ _ | |
| lemma meanParent_lipschitz (V : Point d → ℝ) (S : SeedProgram d) | |
| (E : Expression (Point d × (Point d × Point d)) d) | |
| (u : Fin S.slots → ℝ) (v : Fin E.slots → ℝ) (T Ks Kx Ky : ℝ) | |
| (hKy : 0≤Ky) (hT : 0≤T) | |
| (hS : ∀x y g,‖S.program.run V (x,g)-S.program.run V (y,g)‖≤Ks*‖x-y‖) | |
| (hEx : ∀x y Y G g,‖E.eval V (x,(Y,G)) g-E.eval V (y,(Y,G)) g‖≤Kx*‖x-y‖) | |
| (hEy : ∀x Y Z G g,‖E.eval V (x,(Y,G)) g-E.eval V (x,(Z,G)) g‖≤Ky*‖Y-Z‖) : | |
| ∀x y g,‖(meanParent S E u v T).program.run V (x,g)-(meanParent S E u v T).program.run V (y,g)‖≤ | |
| (Kx+Ky*T*Ks)*‖x-y‖ := by | |
| intro x y g | |
| rw [meanParent_run S E u v T V x g,meanParent_run S E u v T V y g] | |
| have hx := hEx x y (T • S.program.run V (x,leftBlock g)) (middleBlock g 0) (rightBlock g) | |
| have hy := hEy y (T • S.program.run V (x,leftBlock g)) (T • S.program.run V (y,leftBlock g)) | |
| (middleBlock g 0) (rightBlock g) | |
| rw [←smul_sub,norm_smul,Real.norm_eq_abs,abs_of_nonneg hT] at hy | |
| have hs := mul_le_mul_of_nonneg_left (hS x y (leftBlock g)) (mul_nonneg hKy hT) | |
| have hn := norm_sub_le_norm_sub_add_norm_sub | |
| (E.eval V (x,(T • S.program.run V (x,leftBlock g),middleBlock g 0)) (rightBlock g)) | |
| (E.eval V (y,(T • S.program.run V (x,leftBlock g),middleBlock g 0)) (rightBlock g)) | |
| (E.eval V (y,(T • S.program.run V (y,leftBlock g),middleBlock g 0)) (rightBlock g)) | |
| nlinarith | |
| end LogConcaveSampling.OracleCompiler | |
| end | |
| end | |
| section | |
| noncomputable section | |
| namespace LogConcaveSampling | |
| open MeasureTheory ProbabilityTheory OracleCompiler Program Coupling Expression | |
| open scoped Classical BigOperators NNReal | |
| variable {d : ℕ} | |
| theorem terminalReservedProgram_squared {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam) | |
| (x : Point d) {r : ℝ} (hr : 0≤r) (hl : (lam:ℝ)*r^2≤1/2) (η : ℝ) : | |
| SquaredAt (gaussianTape d 2) ((gibbs (primitivePotential F x r)).prod (stdGaussian (Point d))) | |
| (fun g => (terminalReservedProgram d r η).pre.run F (x,g)) | |
| (fun z => z.1+(Real.sqrt 3*η/2) • z.2) | |
| ((terminalTransportConstant*((lam:ℝ)*r^2))^2* | |
| (2*(Real.pi*Real.sqrt d+2*r*‖primitiveField F x r 0‖)^2+2*d)) := by | |
| let f := fullProbabilityFlow hF x hr hl 1 | |
| have hf : Measurable f := (fullProbabilityFlow_lipschitz hF x hr hl ⟨by norm_num,le_rfl⟩).continuous.measurable | |
| have hm : Measurable (fun z => ‖f z-(z-r • primitiveField F x r z)‖^2) := by | |
| have hh := (primitiveField_contDiff hF x r).continuous.measurable | |
| fun_prop | |
| have hp := terminal_sample_squared_error hF x hr hl | |
| have hlaw : (gaussianTape d 2).map (fun g => (f (g 0),g 1))= | |
| (gibbs (primitivePotential F x r)).prod (stdGaussian (Point d)) := by | |
| have hpair := (measurePreserving_finTwoArrow (stdGaussian (Point d))).map_eq | |
| have ht := congrArg (Measure.map (Prod.map f id)) hpair | |
| rw [Measure.map_map (by fun_prop) (by fun_prop),←Measure.map_prod_map _ _ hf measurable_id, | |
| Measure.map_id,hp.1] at ht | |
| exact ht | |
| have he (g : Fin 2 → Point d) : | |
| ‖(terminalReservedProgram d r η).pre.run F (x,g)- | |
| (f (g 0)+(Real.sqrt 3*η/2) • g 1)‖^2= | |
| ‖f (g 0)-((g 0)-r • primitiveField F x r (g 0))‖^2 := by | |
| rw [terminalReservedProgram_pre_run,add_sub_add_right_eq_sub,norm_sub_rev] | |
| rfl | |
| apply SquaredAt.of_joint (gaussianTape d 2) (gaussianTape d 2) | |
| ((gibbs (primitivePotential F x r)).prod (stdGaussian (Point d))) | |
| id (fun g => (f (g 0),g 1)) measurable_id (by fun_prop) Measure.map_id hlaw | |
| _ _ ?_ (by fun_prop) | |
| · simpa only [id_eq,he] using gaussianTape_integrable_eval _ hm hp.2.1 (0:Fin 2) | |
| · simpa only [id_eq,he,gaussianTape_integral_eval _ hm (0:Fin 2)] using hp.2.2 | |
| · have hg := hF.gradient_lipschitz.continuous.measurable | |
| simp only [terminalReservedProgram_pre_run] | |
| fun_prop | |
| lemma terminalReservedProgram_equivariant (r η : ℝ) (Δ : Point d) : | |
| (terminalReservedProgram d r η).pre.Equivariant | |
| (moveSeed (fun x => x+r • Δ) (terminalReservedProgram d r η).shift Δ) (fun y => y-Δ) := by | |
| change (oneQuery (fun p : Point d × (Fin 2 → Point d) => p.1+r • p.2 0) (by fun_prop) | |
| (fun p => p.1.2 0-r • p.2.2+(Real.sqrt 3*η/2) • p.1.2 1) (by fun_prop)).Equivariant _ _ | |
| apply Program.oneQuery_equivariant | |
| · intro p | |
| simp [moveSeed,shiftSlots,terminalReservedProgram,SeedCompiler.terminalShift] | |
| module | |
| · intro p z | |
| simp [moveSeed,shiftSlots,terminalReservedProgram,SeedCompiler.terminalShift] | |
| module | |
| lemma terminalReservedProgram_lipschitz (r η : ℝ) {F : Point d → ℝ} {lam : ℝ≥0} | |
| (hF : Primitive F lam) : ∀x y g, | |
| ‖(terminalReservedProgram d r η).pre.run F (x,g)-(terminalReservedProgram d r η).pre.run F (y,g)‖≤ | |
| |r| *(lam:ℝ)*‖x-y‖ := by | |
| intro x y g | |
| change Fin 2 → Point d at g | |
| rw [terminalReservedProgram_pre_run r η F x g,terminalReservedProgram_pre_run r η F y g,add_sub_add_right_eq_sub] | |
| have he : g 0-r • gradient F (x+r • g 0)-(g 0-r • gradient F (y+r • g 0))= | |
| (-r) • (gradient F (x+r • g 0)-gradient F (y+r • g 0)) := by module | |
| rw [he,norm_smul,Real.norm_eq_abs,abs_neg] | |
| have hh := hF.gradient_lipschitz.dist_le_mul (x+r • g 0) (y+r • g 0) | |
| rw [dist_eq_norm,dist_eq_norm,add_sub_add_right_eq_sub] at hh | |
| exact (mul_le_mul_of_nonneg_left hh (abs_nonneg r)).trans_eq (by ring) | |
| end LogConcaveSampling | |
| end | |
| end | |
| end OAI | |