| import Mathlib |
| import OAI.Probability.LogConcave.OraclePrograms.Shape |
| import OAI.Probability.LogConcave.OraclePrograms.SampleCorrect |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace LogConcaveSampling.OracleCompiler |
| open Filter MeanTree MeasureTheory ProbabilityTheory |
| open scoped Classical NNReal Topology |
|
|
| variable {d : ℕ} |
|
|
| def StandaloneCorrect (F : Point d → ℝ) (lam q K e ηmin : ℝ) : |
| {k : RoutineKind} → RoutineValue d k → Prop |
| | .mean,M => MeanCorrect F lam q K e M |
| | .sample,S => SampleCorrect F lam q K e ηmin S |
|
|
| def UniformAccuracy (κ t w : ℝ) (_ : ℝ) (n N : ℕ) (ht : 0 < t) (hts : t≤1/44) |
| (L : RoutineLabel) : Prop := |
| ∀q : ℕ → ℝ,LogPowerRate q (κ*L.b) → (∀ᶠ d : ℕ in atTop,0 < q d) → |
| ∃K : ℝ,0 ≤ K ∧ ∃e : ℕ → ℝ,LogPowerRate e (κ*L.p) ∧ |
| (∀ᶠ d : ℕ in atTop,0 < e d) ∧ |
| ∀ᶠ d : ℕ in atTop,∀C : CircuitParameters,SourceShape κ t w n N d C → |
| ∀{F : Point d → ℝ} {lam : ℝ≥0},∀_ : Primitive F lam,0 < lam → (lam:ℝ)≤1 → |
| StandaloneCorrect F lam (q d) K (e d) ((d:ℝ)^(-(κ*t))) (constructRoutine d C ht hts L) |
|
|
| lemma sourceA_pos (κ t w : ℝ) (n d : ℕ) : 0 < sourceA κ t w n d := by |
| have hB := (fixedCenteringBudget_spec n).1 |
| have hP := (fixedProbabilityBudget_spec n).1 |
| unfold sourceA |
| positivity |
|
|
| lemma childSizes_positive {κ t w : ℝ} (n : ℕ) {q : ℕ → ℝ} |
| (hq : ∀ᶠ d : ℕ in atTop,0 < q d) : |
| (∀ᶠ d : ℕ in atTop,0 < meanFinalSize κ t n q d) ∧ |
| (∀ᶠ d : ℕ in atTop,0 < sampleFinalSize n q d) ∧ |
| (∀ᶠ d : ℕ in atTop,0 < internalSize κ t w n q d) ∧ |
| (∀ᶠ d : ℕ in atTop,0 < anchorSize κ t q d) := by |
| have h : ∀ᶠ d : ℕ in atTop,0 < meanFinalSize κ t n q d ∧ 0 < sampleFinalSize n q d ∧ |
| 0 < internalSize κ t w n q d ∧ 0 < anchorSize κ t q d := by |
| filter_upwards [hq,eventually_ge_atTop (1:ℕ)] with d hd hd1 |
| have hd0 : (0:ℝ)<d := by exact_mod_cast hd1 |
| have hAf := sourceAf_pos n |
| have hA := sourceA_pos κ t w n d |
| unfold meanFinalSize sampleFinalSize internalSize anchorSize |
| exact ⟨by positivity,by positivity,by positivity,by positivity⟩ |
| exact ⟨h.mono (fun _ h => h.1),h.mono (fun _ h => h.2.1),h.mono (fun _ h => h.2.2.1),h.mono (fun _ h => h.2.2.2)⟩ |
|
|
| lemma uniformAccuracy_terminal {κ t w J K₀ : ℝ} {n N : ℕ} (hκ : 0 < κ) |
| (ht : 0 < t) (hts : t≤1/44) (L : RoutineLabel) (hL : L.Admissible t K₀) |
| (hterm : L.terminal) : UniformAccuracy κ t w J n N ht hts L := by |
| intro q hq hqpos |
| have hb := hL.b_lower ht.le |
| have hqsmall := hq.eventually_lt_const (show 0 < κ*L.b by positivity [hb]) |
| (by norm_num : (0:ℝ)<1/2) |
| cases L with | mk kind b p => |
| cases kind with |
| | mean => |
| let c := 4*(Real.pi+2) |
| have hc : 0 < c := by dsimp [c]; positivity [Real.pi_pos] |
| refine ⟨1,by norm_num,(fun d => c*q d),(hq.const_mul c).mono (by dsimp [RoutineLabel.terminal] at hterm; nlinarith),?_,?_⟩ |
| · exact hqpos.mono (fun _ h => mul_pos hc h) |
| · filter_upwards [hqsmall] with d hd C hC F lam hF hlam hlam1 |
| rw [constructRoutine,dite_eq_left hterm] |
| exact terminalMean_correct hF ((le_abs_self _).trans hd.le) |
| | sample => |
| let c := 2*terminalTransportConstant*(Real.pi+3) |
| have hc : 0 < c := by dsimp [c]; positivity [terminalTransportConstant_pos,Real.pi_pos] |
| refine ⟨1,by norm_num,(fun d => c*q d),(hq.const_mul c).mono (by dsimp [RoutineLabel.terminal] at hterm; nlinarith),?_,?_⟩ |
| · exact hqpos.mono (fun _ h => mul_pos hc h) |
| · filter_upwards [hqsmall] with d hd C hC F lam hF hlam hlam1 |
| rw [constructRoutine,dite_eq_left hterm] |
| exact terminalSample_correct hF ((le_abs_self _).trans hd.le) _ |
|
|
| theorem uniform_routine_accuracy {κ t w J K₀ : ℝ} {n N : ℕ} |
| (hκ : 0 < κ) (ht : 0 < t) (hts : t<1/100) (hw : 0 < w) (hwt : w<t) |
| (hJK : K₀≤J) (_ : N=numericalLayerCount J) |
| (hbudget : ∀ᶠ d : ℕ in atTop,∀C : CircuitParameters,SourceShape κ t w n N d C → |
| ∃B : ℕ,(B:ℝ)≤C.D ∧ ∀L : RoutineLabel,L.Admissible t K₀ → |
| RoutineBudget B (Real.sqrt (1-C.T^2)/C.T) 1 (constructRoutine d C ht (by linarith) L)) |
| (hnum : ∀q : ℕ → ℝ,LogPowerRate q (κ*(1/2)) → |
| ∀ᶠ d : ℕ in atTop,∀C : CircuitParameters,SourceShape κ t w n N d C → |
| ∀{F : Point d → ℝ} {lam : ℝ≥0},∀hF : Primitive F lam,0 < lam → (lam:ℝ)≤1 → |
| ∀hql : q d≤1/4,C.MeanNumericalReady hF (q d) ((d:ℝ)^(-(κ*J))) hql ∧ |
| C.SampleNumericalReady hF (q d) ((d:ℝ)^(-(κ*J)))) : |
| ∀L : RoutineLabel,L.Admissible t K₀ → UniformAccuracy κ t w J n N ht (by linarith) L := by |
| let hts' : t≤1/44 := by linarith |
| apply routine_induction ht hts' |
| · intro L hterm hL |
| exact uniformAccuracy_terminal hκ ht hts' L hL hterm |
| · intro L hnt ih hL q hq hqpos |
| have hb := hL.b_lower ht.le |
| have hpJ : L.p≤J := hL.2.1.trans hJK |
| have hqp := childSizes_positive (κ:=κ) (t:=t) (w:=w) n hqpos |
| have hqi := internalSize_rate hκ ht hw hwt n hq |
| have hqnum := hnum q (hq.mono (by nlinarith)) |
| have hsmall := (small_coefficient_rate hκ ht hw hwt hts hb n hq).eventually_lt_const |
| (by positivity : 0 < κ/3) (by positivity : (0:ℝ)<1/(2*(2*Real.pi+2))) |
| have hqsmall := hq.eventually_lt_const (show 0 < κ*L.b by positivity [hb]) |
| (by norm_num : (0:ℝ)<1/4) |
| have hgeom := sourceCorrelation_eventually (mul_pos hκ ht) |
| have hanchor := source_anchor_radius (mul_pos hκ ht) |
| let H : ℝ := (4*(N+1)^2:ℕ) |
| have hH : 0 ≤ H := Nat.cast_nonneg _ |
| have hAf : 0 < sourceAf n := sourceAf_pos n |
| cases L with | mk kind b p => |
| cases kind with |
| | mean => |
| have hLF := RoutineStep.meanFinal (t:=t) b p |
| have hLI := RoutineStep.internal (t:=t) RoutineKind.mean RoutineKind.mean b p |
| have hLS := RoutineStep.internal (t:=t) RoutineKind.mean RoutineKind.sample b p |
| have hAF := hL.child ht.le hnt hLF |
| have hAI := hL.child ht.le hnt hLI |
| have hAS := hL.child ht.le hnt hLS |
| obtain ⟨Kf,hKf,ef,hef,hefpos,hf⟩ := ih _ hLF hAF (meanFinalSize κ t n q) (meanFinalSize_rate n hq) hqp.1 |
| obtain ⟨Ki,hKi,ei,hei,heipos,hi⟩ := ih _ hLI hAI (internalSize κ t w n q) hqi hqp.2.2.1 |
| obtain ⟨Ks,hKs,es,hes,hespos,hS⟩ := ih _ hLS hAS (anchorSize κ t q) (anchorSize_rate hκ.le ht.le hq) hqp.2.2.2 |
| let e := fun d => 2*(sourceAf n*Kf*H*q d)*es d+ |
| 10*(20+16*circuitGrowthConstant^2)*(2*(1+2*H)*(sourceAf n*Kf*q d*ei d+ef d))+ |
| 2*(d:ℝ)^(-(κ*J)) |
| have he : LogPowerRate e (κ*p) := by |
| apply (meanError_rate hκ.le hb hpJ (sourceAf n) H Kf hq hes hei hef).congr |
| filter_upwards [] with d |
| dsimp only [e] |
| ring |
| have hepos : ∀ᶠ d : ℕ in atTop,0 < e d := by |
| filter_upwards [hqpos,hefpos,heipos,hespos,eventually_ge_atTop (1:ℕ)] with d hqd hfd hid hsd hd1 |
| have hd0 : (0:ℝ)<d := by exact_mod_cast hd1 |
| dsimp [e] |
| positivity |
| refine ⟨2*sourceAf n*H*Kf,by positivity,e,he,hepos,?_⟩ |
| have hcon := ((small_coefficient_rate hκ ht hw hwt hts hb n hq).const_mul (4*Ki)).eventually_lt_const |
| (by positivity : 0 < κ/3) (by norm_num : (0:ℝ)<1) |
| have hqs := (hq.mul_const Ks).eventually_lt_const (show 0 < κ*b by positivity [hb]) (by norm_num : (0:ℝ)<1) |
| filter_upwards [hf,hi,hS,hbudget,hqnum,hqpos,hefpos,heipos,hespos,hsmall,hcon,hqs,hqsmall,hgeom,hanchor, |
| eventually_ge_atTop (1:ℕ)] with d hfd hid hsd hbd hnd hqd hef0 hei0 hes0 hsm hco hqsd hql hdgeom hdanchor hd1 |
| intro C hC F lam hF hlam hlam1 |
| have hd0 : (0:ℝ)<d := by exact_mod_cast hd1 |
| have hR : Real.sqrt (1-C.T^2)=(d:ℝ)^(-(κ*t)) := by |
| rw [hC.T_eq,←hdgeom.2.2,Real.sqrt_sq (Real.rpow_pos_of_pos hd0 _).le] |
| have hRT : Real.sqrt (1-C.T^2)≤C.T := by |
| apply (div_le_one (by linarith [C.T_lower] : 0 < C.T)).mp |
| rw [hC.T_eq] |
| exact hdanchor.2 |
| have hη : (d:ℝ)^(-(κ*t))≤Real.sqrt (1-C.T^2)/C.T := by rw [hC.T_eq]; exact hdanchor.1 |
| have hD : 1≤C.D := by rw [hC.D_eq]; exact Real.one_le_rpow (by exact_mod_cast hd1) (mul_pos hκ ht).le |
| have hψ : 0 ≤ C.ψ := by rw [hC.ψ_eq]; positivity |
| obtain ⟨B,hBD,hbud⟩ := hbd C hC |
| have hB : (B:ℝ)≤C.D^2 := hBD.trans (by nlinarith) |
| have hsmall' : 2*C.A*q d*(2*Real.pi+2)≤1 := by |
| rw [hC.A] |
| have hh := (le_abs_self _).trans hsm.le |
| have hp : 0 < 2*(2*Real.pi+2) := by positivity [Real.pi_pos] |
| have he := (le_div_iff₀ hp).mp hh |
| nlinarith only [he] |
| have hcon' : 4*C.A*q d*Ki≤1 := by |
| rw [hC.A] |
| have he := (le_abs_self _).trans hco.le |
| nlinarith only [he] |
| have hnmc : C.m=C.n := hC.m_eq.trans hC.n_eq.symm |
| have hncc : C.nc=C.n := hC.nc_eq.trans hC.n_eq.symm |
| have hNcc : C.Nc=C.N := hC.Nc_eq.trans hC.N_eq.symm |
| have hqle : q d≤1/4 := (le_abs_self _).trans hql.le |
| have hfc := hfd C hC hF hlam hlam1 |
| have hic := hid C hC hF hlam hlam1 |
| have hsc := hsd C hC hF hlam hlam1 |
| have hf' : MeanCorrect F lam ((1+4*C.Af)*Real.sqrt (1-C.T^2)*q d) Kf (ef d) |
| (constructRoutine d C ht hts' ⟨.mean,b+t,p⟩) := by |
| simpa only [StandaloneCorrect,meanFinalSize,hC.Af,hR] using hfc |
| have hi' : MeanCorrect F lam (q d*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki (ei d) |
| (constructRoutine d C ht hts' ⟨.mean,b-10*t,p-1/4⟩) := by |
| simpa only [StandaloneCorrect,internalSize,hC.D_eq,hC.A,hR] using hic |
| have hs' : SampleCorrect F lam (q d/Real.sqrt (1-C.T^2)) Ks (es d) ((d:ℝ)^(-(κ*t))) |
| (constructRoutine d C ht hts' ⟨.sample,b-10*t,p-1/4⟩) := by |
| simpa only [StandaloneCorrect,anchorSize,hR] using hsc |
| have hp := C.meanFrom_correct hF hd1 hlam1 hqd.le hqle hRT hη hD hψ hC.A_eq hC.Af_eq |
| hKf hKi hKs hef0 hei0.le hes0.le (Real.rpow_pos_of_pos hd0 _).le hsmall' hcon' |
| ((le_abs_self _).trans hqsd.le) hnmc hncc hNcc _ _ _ B hB |
| (fun s r τ => by cases s; exact hbud _ hAI r τ; exact hbud _ hAF r τ) |
| hf' hi' hs' (fun r => (hbud _ hAS r _ (Or.inl rfl)).reserve) |
| (hnd C hC hF hlam hlam1 hqle).1 |
| rw [constructRoutine,dite_eq_right hnt] |
| simpa only [StandaloneCorrect,hC.Af,hC.depth,CircuitParameters.meanError, |
| CircuitParameters.compilerError,e,H] using hp |
| | sample => |
| have hLF := RoutineStep.sampleFinal (t:=t) b p |
| have hLI := RoutineStep.internal (t:=t) RoutineKind.sample RoutineKind.mean b p |
| have hAF := hL.child ht.le hnt hLF |
| have hAI := hL.child ht.le hnt hLI |
| obtain ⟨Kf,hKf,ef,hef,hefpos,hf⟩ := ih _ hLF hAF (sampleFinalSize n q) (sampleFinalSize_rate n hq) hqp.2.1 |
| obtain ⟨Ki,hKi,ei,hei,heipos,hi⟩ := ih _ hLI hAI (internalSize κ t w n q) hqi hqp.2.2.1 |
| let e := fun d => 20*(2*(1+2*H)*(sourceAf n*Kf*q d*ei d+ef d))+2*(d:ℝ)^(-(κ*J)) |
| have he : LogPowerRate e (κ*p) := sampleError_rate hκ.le hb hpJ (sourceAf n) H Kf hq hei hef |
| have hepos : ∀ᶠ d : ℕ in atTop,0 < e d := by |
| filter_upwards [hqpos,hefpos,heipos,eventually_ge_atTop (1:ℕ)] with d hqd hfd hid hd1 |
| have hd0 : (0:ℝ)<d := by exact_mod_cast hd1 |
| dsimp [e] |
| positivity |
| refine ⟨sourceAf n*H*Kf,by positivity,e,he,hepos,?_⟩ |
| have hcon := ((small_coefficient_rate hκ ht hw hwt hts hb n hq).const_mul (4*Ki)).eventually_lt_const |
| (by positivity : 0 < κ/3) (by norm_num : (0:ℝ)<1) |
| filter_upwards [hf,hi,hbudget,hqnum,hqpos,hefpos,heipos,hsmall,hcon,hqsmall,hgeom, |
| eventually_ge_atTop (1:ℕ)] with d hfd hid hbd hnd hqd hef0 hei0 hsm hco hql hdgeom hd1 |
| intro C hC F lam hF hlam hlam1 |
| have hd0 : (0:ℝ)<d := by exact_mod_cast hd1 |
| have hR : Real.sqrt (1-C.T^2)=(d:ℝ)^(-(κ*t)) := by |
| rw [hC.T_eq,←hdgeom.2.2,Real.sqrt_sq (Real.rpow_pos_of_pos hd0 _).le] |
| have hD : 1≤C.D := by rw [hC.D_eq]; exact Real.one_le_rpow (by exact_mod_cast hd1) (mul_pos hκ ht).le |
| obtain ⟨B,hBD,hbud⟩ := hbd C hC |
| have hB : (B:ℝ)≤C.D^2 := hBD.trans (by nlinarith) |
| have hsmall' : 2*C.A*q d*(2*Real.pi+2)≤1 := by |
| rw [hC.A] |
| have hh := (le_abs_self _).trans hsm.le |
| have hp : 0 < 2*(2*Real.pi+2) := by positivity [Real.pi_pos] |
| have he := (le_div_iff₀ hp).mp hh |
| nlinarith only [he] |
| have hcon' : 4*C.A*q d*Ki≤1 := by |
| rw [hC.A] |
| have he := (le_abs_self _).trans hco.le |
| nlinarith only [he] |
| have hqle : q d≤1/4 := (le_abs_self _).trans hql.le |
| have hf' : MeanCorrect F lam ((1+4*C.Af)*q d) Kf (ef d) |
| (constructRoutine d C ht hts' ⟨.mean,b,p⟩) := by |
| simpa only [StandaloneCorrect,sampleFinalSize,hC.Af] using hfd C hC hF hlam hlam1 |
| have hi' : MeanCorrect F lam (q d*(1+16*C.D*C.A/Real.sqrt (1-C.T^2))) Ki (ei d) |
| (constructRoutine d C ht hts' ⟨.mean,b-10*t,p-1/4⟩) := by |
| simpa only [StandaloneCorrect,internalSize,hC.D_eq,hC.A,hR] using hid C hC hF hlam hlam1 |
| have hp := C.sampleFrom_correct hF hd1 hlam1 hqd.le hqle hR.le hD hC.A_eq hC.Af_eq |
| hKf hKi hef0 hei0.le (Real.rpow_pos_of_pos hd0 _).le hsmall' hcon' |
| _ _ B hB (fun s r τ => by cases s; exact hbud _ hAI r τ; exact hbud _ hAF r τ) |
| hf' hi' (hnd C hC hF hlam hlam1 hqle).2 |
| rw [constructRoutine,dite_eq_right hnt] |
| simpa only [StandaloneCorrect,hC.Af,hC.depth,CircuitParameters.sampleError, |
| CircuitParameters.compilerError,e,H] using hp |
| end LogConcaveSampling.OracleCompiler |
|
|
| end |
|
|
| end |
|
|
| section |
|
|
| noncomputable section |
| namespace LogConcaveSampling |
| open Filter MeasureTheory ProbabilityTheory |
| open scoped Classical NNReal |
|
|
| theorem calibrated_sample_circuit_order {κ J b w : ℝ} (hκ : 0<κ) (hJ : 1≤J) |
| (hb : 1/2≤b) (hw : 0<w) (n : ℕ) (hn : 0<n) |
| (hnw : J+10<w*((n:ℝ)-3)) : |
| ∀{S : ℝ},0≤S → ∀ksize : ℕ,∀ᶠ d : ℕ in atTop, |
| let h := (d:ℝ)^(-(κ*w)) |
| ∃_ : 0<h,∀{F : Point d → ℝ} {lam : ℝ≥0},∀hF : Primitive F lam,∀x : Point d, |
| ∀{r : ℝ},∀hr : 0<r,r≤1 → 0<lam → (lam:ℝ)*r≤1 → |
| (lam:ℝ)*r^2≤S*dimensionLog d^ksize*(d:ℝ)^(-(κ*b)) → |
| ∃hl : (lam:ℝ)*r^2≤1/2,∀{T : ℝ},1/2≤T → T<1 → ∀e : ProbabilityNode T h n, |
| Integrable (fun z => ‖sampleMeanCircuit F x r T h n (numericalLayerCount J) e z- |
| T⁻¹ • fullProbabilityFlow hF x hr.le hl (probabilityNodeTime T h n e) z‖^2) |
| (stdGaussian (Point d)) ∧ |
| (∫z,‖sampleMeanCircuit F x r T h n (numericalLayerCount J) e z- |
| T⁻¹ • fullProbabilityFlow hF x hr.le hl (probabilityNodeTime T h n e) z‖^2 ∂stdGaussian (Point d))≤ |
| (circuitD F x)^2*(d:ℝ)^(-(2*κ*J)) := by |
| obtain ⟨A,C,hC,k,hproducer⟩ := sampleMeanCircuit_rms n hn |
| intro S hS ksize |
| have hc := sampleScalarCalibration_uniform k n (numericalLayerCount J) ksize A C hS hκ hJ hb hw hnw |
| (numericalLayerCount_bound J) |
| have hhsmall := (LogPowerRate.power (κ*w)).eventually_lt_const (mul_pos hκ hw) |
| (Real.log_pos (by norm_num : (1:ℝ)<2)) |
| filter_upwards [hc,hhsmall,eventually_ge_atTop (1:ℕ)] with d hd hdh hdim |
| intro h |
| have hdpos : (0:ℝ)<d := by exact_mod_cast hdim |
| have hh : 0<h := Real.rpow_pos_of_pos hdpos _ |
| refine ⟨hh,?_⟩ |
| intro F lam hF x r hr hr1 hlam hL hl₀ |
| obtain ⟨hl,hq,he⟩ := hd lam r hr hl₀ |
| refine ⟨hl,?_⟩ |
| intro T hT hT1 e |
| have hp := hproducer hF x hr hr1 hlam hl hL hdim hT hT1 hh |
| ((le_abs_self _).trans hdh.le) hq (numericalLayerCount J) e |
| exact ⟨hp.1,hp.2.trans (mul_le_mul_of_nonneg_left he (sq_nonneg _))⟩ |
| end LogConcaveSampling |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
