| import Mathlib |
| import OAI.Probability.LogConcave.OraclePrograms.MeanCorrect |
| import OAI.Probability.LogConcave.Sampling.PairGauge |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace LogConcaveSampling.OracleCompiler |
| open MeasureTheory ProbabilityTheory MeanTree Coupling SeedCompiler |
| open scoped Classical BigOperators NNReal |
|
|
| variable {d : ℕ} |
|
|
| lemma MeanBudget.shiftInvariant {B : ℕ} {r : ℝ} {S : SeedProgram d} |
| (h : MeanBudget B r S) (F : Point d → ℝ) : |
| ShiftInvariant r S.shift (fun c g => S.program.run F (c,g)) := by |
| intro x Δ g |
| exact (h.equiv Δ).run F (x,g) |
|
|
| namespace CircuitParameters |
| variable (C : CircuitParameters) |
| lemma meanCompiled_squared {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam) |
| {q Kf Ki ef ei r σ : ℝ} (hs : MeanSize lam q r σ) (hl : q≤1/2) |
| (hL : (lam:ℝ)*r≤1) (hD : 0<C.D) (hψ : 0≤C.ψ) |
| (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf) |
| (hKf : 0≤Kf) (hKi : 0≤Ki) |
| (hsmall : (lam:ℝ)*C.meanCenterBudget r σ*(2*Real.pi+2)≤1) |
| (hcon : 4*(C.meanCenterBudget r σ)^2*((lam:ℝ)*Ki)^2≤1) |
| (Mf Mi : ℝ → ℝ → SeedProgram d) (B : ℕ) (hBD : (B:ℝ)≤C.D^2) |
| (hbudget : ∀(s : Bool) r τ,MeanBudget B r ((if s then Mf else Mi) r τ)) |
| (hf : MeanCorrect F lam ((1+4*C.Af)*Real.sqrt (1-C.T^2)*q) Kf ef Mf) |
| (hi : MeanCorrect F lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki ei Mi) |
| (x Y G : Point d) : |
| let E := compileDeclaredRoot C.D (C.meanCenterBudget r σ) C.Af Mf Mi |
| (C.meanTree (d:=d) r σ) (Real.sqrt 3*σ/2) |
| SquaredAt (gaussianTape d E.slots) (stdGaussian (Point d)) (E.eval F (x,(Y,G))) |
| (fun g => (C.meanTree r σ).eval F (x,(Y,G))+(Real.sqrt 3*σ/2) • g) |
| ((2*C.Af^2*((lam:ℝ)*Kf)^2*(r/(2*C.D))^2*ei^2+(Real.sqrt 3*σ/2)^2*ef^2/2)* |
| (2*(depth (C.meanTree (d:=d) r σ):ℝ)*pairGauge (circuitD F x) (Y,G))^2) := by |
| have hr := hs.1 |
| have hn := hs.2.2.1 |
| let P : Bool → ℝ → ℝ → Prop := fun s => if s then |
| MeanSize lam ((1+4*C.Af)*Real.sqrt (1-C.T^2)*q) else |
| MeanSize lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) |
| let M : Bool → ℝ → ℝ → SeedProgram d := fun s => if s then Mf else Mi |
| have hb (s : Bool) (r τ : ℝ) := hbudget s r τ |
| have hV : Measurable (firstOrderReply F) := hF.smooth.continuous.measurable.prodMk |
| hF.gradient_lipschitz.continuous.measurable |
| have hv := C.meanTree_valid (d:=d) lam.coe_nonneg hs hD hψ hA hAf |
| have hw := C.meanTree_actual_weights (d:=d) hs.1 hs.2.2.1 hψ |
| rw [←hAf,←hA] at hw |
| have hg := (literalMean_geometry (d:=d) (r:=r) (σ:=σ) (N:=C.N) (nc:=C.nc) (Nc:=C.Nc) |
| (by linarith [C.T_lower]) C.T_upper C.h_pos C.v_nonneg C.angle_bound C.meanEndpoint).2 |
| have hrs : centers (fun r' _ => 0≤r' ∧ r'≤r) (C.meanTree (d:=d) r σ) := |
| centers_mono _ (fun r' b hb => ⟨(hb.radius_pos hs.1 (by linarith [C.T_lower]) C.T_upper).le, |
| (hb.radius hs.1.le (by linarith [C.T_lower]) C.T_upper).2⟩) hg |
| exact compileDeclaredRoot_normalized F F hV hD |
| (by unfold meanCenterBudget; rw [hA]; positivity [C.actualA_pos]) |
| (by rw [hAf]; exact C.actualAf_pos) (mul_nonneg lam.coe_nonneg hKi) (mul_nonneg lam.coe_nonneg hKf) |
| hcon P M (fun s r τ _ => (hb s r τ).shiftInvariant F) |
| (fun s r τ _ => (hb s r τ).energy.trans hBD) hi.lip hf.lip hi.error hf.error |
| (C.meanTree r σ) (x,(Y,G)) hv hw.2 hrs |
| (C.meanTree_centerValues hF hs.1 hs.2.2.1 hψ hA (hs.2.2.2.1.trans hl) hL hsmall x Y G) |
|
|
| lemma sampleCompiled_squared {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam) |
| {q Kf Ki ef ei r η : ℝ} (hs : SampleSize lam q r η) (hl : q≤1/2) |
| (hL : (lam:ℝ)*r≤1) (hRη : Real.sqrt (1-C.T^2)≤η) (hD : 0<C.D) |
| (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf) |
| (hKf : 0≤Kf) (hKi : 0≤Ki) |
| (hsmall : (lam:ℝ)*C.sampleCenterBudget r*(2*Real.pi+2)≤1) |
| (hcon : 4*(C.sampleCenterBudget r)^2*((lam:ℝ)*Ki)^2≤1) |
| (Mf Mi : ℝ → ℝ → SeedProgram d) (B : ℕ) (hBD : (B:ℝ)≤C.D^2) |
| (hbudget : ∀(s : Bool) r τ,MeanBudget B r ((if s then Mf else Mi) r τ)) |
| (hf : MeanCorrect F lam ((1+4*C.Af)*q) Kf ef Mf) |
| (hi : MeanCorrect F lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki ei Mi) |
| (x Y : Point d) : |
| let E := compileDeclaredRoot C.D (C.sampleCenterBudget r) (C.sampleFinalBudget r) Mf Mi |
| (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1) (η/Real.sqrt 2) |
| SquaredAt (gaussianTape d E.slots) (stdGaussian (Point d)) (E.eval F (x,Y)) |
| (fun g => (C.sampleTree r η hs.2.2.1 hs.2.2.2.1).eval F (x,Y)+(η/Real.sqrt 2) • g) |
| ((2*(C.sampleFinalBudget r)^2*((lam:ℝ)*Kf)^2*(r/(2*C.D))^2*ei^2+(η/Real.sqrt 2)^2*ef^2/2)* |
| ((depth (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1):ℝ)*anchorGauge (circuitD F x) Y)^2) := by |
| have hr := hs.1 |
| have hn := hs.2.2.1 |
| let P : Bool → ℝ → ℝ → Prop := fun s => if s then |
| MeanSize lam ((1+4*C.Af)*q) else MeanSize lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) |
| let M : Bool → ℝ → ℝ → SeedProgram d := fun s => if s then Mf else Mi |
| have hb (s : Bool) (r τ : ℝ) := hbudget s r τ |
| have hV : Measurable (firstOrderReply F) := hF.smooth.continuous.measurable.prodMk |
| hF.gradient_lipschitz.continuous.measurable |
| have hv := C.sampleTree_valid (d:=d) lam.coe_nonneg hs C.residual_pos hRη hD hA hAf |
| have hw := C.sampleTree_actual_weights (d:=d) hs.1 hs.2.2.1 hs.2.2.2.1 |
| rw [←hAf,←hA] at hw |
| have hp := sampleCorrelation_properties hs.2.2.1 hs.2.2.2.1 |
| have hg := (literalSample_geometry (d:=d) (r:=r) (N:=C.N) (Nat.succ_pos C.n) |
| (by linarith [hp.1]) hp.2.1 C.h_pos (C.sampleEndpoint η hs.2.2.1 hs.2.2.2.1)).2 |
| have hrs : centers (fun r' _ => 0≤r' ∧ r'≤r) (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1) := |
| centers_mono _ (fun r' b hb => ⟨(hb.radius_pos hs.1 (by linarith [hp.1]) hp.2.1).le, |
| (hb.radius hs.1.le (by linarith [hp.1]) hp.2.1).2⟩) hg |
| have hl' : (lam:ℝ)*r^2≤1/2 := hs.2.2.2.2.trans |
| ((mul_le_of_le_one_right (hs.nonneg lam.coe_nonneg) hs.2.2.2.1).trans hl) |
| exact compileDeclaredRoot_normalized F F hV hD |
| (by unfold sampleCenterBudget; rw [hA]; positivity [C.actualA_pos]) |
| (by unfold sampleFinalBudget; rw [hAf]; positivity [C.actualAf_pos]) |
| (mul_nonneg lam.coe_nonneg hKi) (mul_nonneg lam.coe_nonneg hKf) |
| hcon P M (fun s r τ _ => (hb s r τ).shiftInvariant F) |
| (fun s r τ _ => (hb s r τ).energy.trans hBD) hi.lip hf.lip hi.error hf.error |
| (C.sampleTree r η hs.2.2.1 hs.2.2.2.1) (x,Y) hv hw.2 hrs |
| (C.sampleTree_centerValues hF hs.1 hs.2.2.1 hs.2.2.2.1 hA hl' hL hsmall x Y) |
| end CircuitParameters |
| end LogConcaveSampling.OracleCompiler |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling.OracleCompiler |
| open MeanTree MeasureTheory |
| open scoped Classical |
|
|
| lemma physicalCoefficient_bound {lam r s D Af K ei ef q n : ℝ} |
| (hl : 0 ≤ lam) (hr : 0 ≤ r) (hs : 0 < s) (hD : 1 ≤ D) (hAf : 0 ≤ Af) |
| (hK : 0 ≤ K) (hi : 0 ≤ ei) (hf : 0 ≤ ef) (hq : lam*r ≤ q*s) |
| (hn : 0 ≤ n) (hns : n ≤ s) : |
| 2*Af^2*(lam*K)^2*(r/(2*D))^2*ei^2+n^2*ef^2/2 ≤ |
| 2*s^2*(Af*K*q*ei+ef)^2 := by |
| have hD0 : 0 < 2*D := by linarith |
| have hq0 : 0 ≤ q := by nlinarith [mul_nonneg hl hr] |
| have hab : lam*r/(2*D) ≤ q*s := by |
| apply (div_le_iff₀ hD0).2 |
| have hh := mul_le_mul_of_nonneg_left (by linarith : (1:ℝ) ≤ 2*D) (mul_nonneg hq0 hs.le) |
| nlinarith |
| have ha : 0 ≤ Af*K*(lam*r/(2*D))*ei := by positivity |
| have hb : Af*K*(lam*r/(2*D))*ei ≤ s*(Af*K*q*ei) := by |
| have hh := mul_le_mul_of_nonneg_left hab (show 0 ≤ Af*K*ei by positivity) |
| nlinarith |
| have hc : n*ef ≤ s*ef := mul_le_mul_of_nonneg_right hns hf |
| have ha2 := pow_le_pow_left₀ ha hb 2 |
| have hb2 := pow_le_pow_left₀ (mul_nonneg hn hf) hc 2 |
| have hid : Af^2*(lam*K)^2*(r/(2*D))^2*ei^2=(Af*K*(lam*r/(2*D))*ei)^2 := by ring |
| have hid2 : 2*Af^2*(lam*K)^2*(r/(2*D))^2*ei^2=2*(Af*K*(lam*r/(2*D))*ei)^2 := by nlinarith [hid] |
| rw [hid2] |
| nlinarith [mul_nonneg (show 0 ≤ Af*K*q*ei by positivity) hf] |
|
|
| lemma physicalError_bound {c s a dep ρ : ℝ} (_hs : 0 ≤ s) (_ha : 0 ≤ a) (hd : 0 ≤ dep) |
| (hc : c ≤ 2*s^2*a^2) : |
| c*(dep*ρ)^2 ≤ (2*s*(1+dep)*a)^2*ρ^2 := by |
| have hh := mul_le_mul_of_nonneg_right hc (sq_nonneg (dep*ρ)) |
| have hdep : 2*dep^2 ≤ (2*(1+dep))^2 := by nlinarith |
| have hh' := mul_le_mul_of_nonneg_right hdep (show 0 ≤ s^2*a^2*ρ^2 by positivity) |
| nlinarith |
|
|
| end LogConcaveSampling.OracleCompiler |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling.OracleCompiler.CircuitParameters |
| open MeanTree MeasureTheory ProbabilityTheory Coupling SeedCompiler |
| open scoped Classical NNReal |
|
|
| variable (C : CircuitParameters) {d : ℕ} |
|
|
| lemma meanCompiled_scaled {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam) |
| {q Kf Ki ef ei r σ : ℝ} (hs : MeanSize lam q r σ) (hl : q ≤ 1/2) |
| (hL : (lam:ℝ)*r ≤ 1) (hD : 1 ≤ C.D) (hψ : 0 ≤ C.ψ) |
| (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf) |
| (hKf : 0 ≤ Kf) (hKi : 0 ≤ Ki) (hef : 0 ≤ ef) (hei : 0 ≤ ei) |
| (hsmall : (lam:ℝ)*C.meanCenterBudget r σ*(2*Real.pi+2) ≤ 1) |
| (hcon : 4*(C.meanCenterBudget r σ)^2*((lam:ℝ)*Ki)^2 ≤ 1) |
| (Mf Mi : ℝ → ℝ → SeedProgram d) (B : ℕ) (hBD : (B:ℝ) ≤ C.D^2) |
| (hbudget : ∀(s : Bool) r τ,MeanBudget B r ((if s then Mf else Mi) r τ)) |
| (hf : MeanCorrect F lam ((1+4*C.Af)*Real.sqrt (1-C.T^2)*q) Kf ef Mf) |
| (hi : MeanCorrect F lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki ei Mi) |
| (x Y G : Point d) : |
| let E := compileDeclaredRoot C.D (C.meanCenterBudget r σ) C.Af Mf Mi |
| (C.meanTree (d:=d) r σ) (Real.sqrt 3*σ/2) |
| let a := 2*(1+2*(depth (C.meanTree (d:=d) r σ):ℝ))*(C.Af*Kf*q*ei+ef) |
| SquaredAt (gaussianTape d E.slots) (stdGaussian (Point d)) (E.eval F (x,(Y,G))) |
| (fun g => (C.meanTree r σ).eval F (x,(Y,G))+(Real.sqrt 3*σ/2) • g) |
| ((σ*a)^2*(pairGauge (circuitD F x) (Y,G))^2) := by |
| have hAf0 : 0 ≤ C.Af := by rw [hAf]; exact C.actualAf_pos.le |
| have hn : Real.sqrt 3*σ/2 ≤ σ := by |
| have hh : Real.sqrt 3 ≤ 2 := by nlinarith [Real.sq_sqrt (by norm_num : (0:ℝ) ≤ 3),Real.sqrt_nonneg (3:ℝ)] |
| nlinarith [mul_le_mul_of_nonneg_right hh hs.2.2.1.le] |
| have hc := physicalCoefficient_bound lam.coe_nonneg hs.1.le hs.2.2.1 hD hAf0 hKf hei hef |
| hs.2.2.2.2 (show 0 ≤ Real.sqrt 3*σ/2 by positivity [hs.2.2.1]) hn |
| have hb := physicalError_bound hs.2.2.1.le |
| (show 0 ≤ C.Af*Kf*q*ei+ef by positivity [hs.nonneg lam.coe_nonneg]) |
| (show 0 ≤ 2*(depth (C.meanTree (d:=d) r σ):ℝ) by positivity) |
| (ρ:=pairGauge (circuitD F x) (Y,G)) hc |
| have hp := C.meanCompiled_squared hF hs hl hL (by linarith) hψ hA hAf hKf hKi hsmall hcon |
| Mf Mi B hBD hbudget hf hi x Y G |
| apply hp.mono |
| convert hb using 1 |
| ring |
|
|
| lemma sampleCompiled_scaled {F : Point d → ℝ} {lam : ℝ≥0} (hF : Primitive F lam) |
| {q Kf Ki ef ei r η : ℝ} (hs : SampleSize lam q r η) (hl : q ≤ 1/2) |
| (hL : (lam:ℝ)*r ≤ 1) (hRη : Real.sqrt (1-C.T^2) ≤ η) (hD : 1 ≤ C.D) |
| (hA : C.A=C.actualA) (hAf : C.Af=C.actualAf) |
| (hKf : 0 ≤ Kf) (hKi : 0 ≤ Ki) (hef : 0 ≤ ef) (hei : 0 ≤ ei) |
| (hsmall : (lam:ℝ)*C.sampleCenterBudget r*(2*Real.pi+2) ≤ 1) |
| (hcon : 4*(C.sampleCenterBudget r)^2*((lam:ℝ)*Ki)^2 ≤ 1) |
| (Mf Mi : ℝ → ℝ → SeedProgram d) (B : ℕ) (hBD : (B:ℝ) ≤ C.D^2) |
| (hbudget : ∀(s : Bool) r τ,MeanBudget B r ((if s then Mf else Mi) r τ)) |
| (hf : MeanCorrect F lam ((1+4*C.Af)*q) Kf ef Mf) |
| (hi : MeanCorrect F lam (q*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki ei Mi) |
| (x Y : Point d) : |
| let E := compileDeclaredRoot C.D (C.sampleCenterBudget r) (C.sampleFinalBudget r) Mf Mi |
| (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1) (η/Real.sqrt 2) |
| let a := 2*(1+(depth (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1):ℝ))*(C.Af*Kf*q*ei+ef) |
| SquaredAt (gaussianTape d E.slots) (stdGaussian (Point d)) (E.eval F (x,Y)) |
| (fun g => (C.sampleTree r η hs.2.2.1 hs.2.2.2.1).eval F (x,Y)+(η/Real.sqrt 2) • g) |
| ((η*a)^2*(anchorGauge (circuitD F x) Y)^2) := by |
| have hAf0 : 0 ≤ C.Af := by rw [hAf]; exact C.actualAf_pos.le |
| have hn : η/Real.sqrt 2 ≤ η := by |
| exact div_le_self hs.2.2.1.le (by nlinarith [Real.sq_sqrt (by norm_num : (0:ℝ) ≤ 2),Real.sqrt_nonneg (2:ℝ)]) |
| have hc := physicalCoefficient_bound (mul_nonneg lam.coe_nonneg hs.1.le) hs.1.le hs.2.2.1 hD hAf0 hKf hei hef |
| (show ((lam:ℝ)*r)*r ≤ q*η by nlinarith [hs.2.2.2.2]) |
| (show 0 ≤ η/Real.sqrt 2 by positivity [hs.2.2.1]) hn |
| have hb := physicalError_bound hs.2.2.1.le |
| (show 0 ≤ C.Af*Kf*q*ei+ef by positivity [hs.nonneg lam.coe_nonneg]) |
| (show 0 ≤ (depth (C.sampleTree (d:=d) r η hs.2.2.1 hs.2.2.2.1):ℝ) by positivity) |
| (ρ:=anchorGauge (circuitD F x) Y) hc |
| have hp := C.sampleCompiled_squared hF hs hl hL hRη (by linarith) hA hAf hKf hKi hsmall hcon |
| Mf Mi B hBD hbudget hf hi x Y |
| apply hp.mono |
| convert hb using 1 <;> (try unfold sampleFinalBudget) <;> ring |
| end LogConcaveSampling.OracleCompiler.CircuitParameters |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
