| import Mathlib |
| import OAI.Probability.LogConcave.Numerics.Cost |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace LogConcaveSampling.MeanTree |
| open MeasureTheory OracleCompiler OracleCompiler.Expression SeedCompiler |
| open scoped Classical BigOperators |
|
|
| variable {X : Type*} [MeasurableSpace X] {d : ℕ} |
|
|
| def compileDeclaredRootShift (D A Af : ℝ) (Mf Mi : ℝ → ℝ → SeedProgram d) : |
| (E : MeanTree X d) → (n : ℝ) → DriftData E → Fin (compileDeclaredRoot D A Af Mf Mi E n).slots → ℝ |
| | .node k b hb a r C,n,p => |
| compileTermsShift D k a (fun i => compileDeclared D A Mi (C i) (r i/(2*D))) |
| (fun i => Mf (r i) (declaredNoise n Af)) (.noise b hb (declaredReserve n Af a)) |
| (fun i => compileDeclaredShift D A Mi (C i) (r i/(2*D)) (p.2 i)) |
| (fun i => inverseChildShift D (r i) ((p.2 i).root (C i)) (Mf (r i) (declaredNoise n Af))) |
| (fun _ => 0) |
|
|
| def RootShiftReady (D A Af : ℝ) (Pf Pi : ℝ → ℝ → Prop) : MeanTree X d → ℝ → Prop |
| | .node _ _ _ _ r C,n => ∀i,r i≠0 ∧ Pf (r i) (declaredNoise n Af) ∧ ShiftReady D A Pi (C i) (r i/(2*D)) |
|
|
| theorem compileDeclaredRoot_equivariant (D A Af : ℝ) (hD : 0<D) |
| (P : Bool → ℝ → ℝ → Prop) (M : Bool → ℝ → ℝ → SeedProgram d) |
| (hv : ∀s r τ,P s r τ → (∑j,(M s r τ).shift j^2) ≤ D^2) |
| (hM : ∀s r τ,P s r τ → ∀Δ,(M s r τ).program.Equivariant |
| (moveSeed (fun x => x+r • Δ) (M s r τ).shift Δ) id) |
| (f : Point d → X → X) (E : MeanTree X d) (n : ℝ) (p : DriftData E) |
| (hp : DriftValid f E p) (hr : RootShiftReady D A Af (P true) (P false) E n) : |
| ∀Δ,(compileDeclaredRoot D A Af (M true) (M false) E n).compile.Equivariant |
| (moveSeed (f Δ) (compileDeclaredRootShift D A Af (M true) (M false) E n p) Δ) |
| (fun y => y+p.root E • Δ) := by |
| cases E with | node k b hb a r C => |
| intro Δ |
| apply compileTerms_equivariant |
| · intro i |
| exact compileDeclared_equivariant D A hD (P false) (M false) (hv false) (hM false) |
| f (C i) (r i/(2*D)) (p.2 i) (hp.2 i) (hr i).2.2 Δ |
| · intro i |
| exact transformed_mean_equivariant (M true (r i) (declaredNoise n Af)).program |
| (hr i).1 _ _ ((normalized_shift_bound hD _ (hv _ _ _ (hr i).2.1)).trans_lt (by norm_num)) |
| (hM _ _ _ (hr i).2.1) ((p.2 i).root (C i)) Δ |
| · exact noise_equivariant b hb _ p.1 (f Δ) Δ (hp.1 Δ) |
|
|
| theorem compileDeclaredRoot_size (D A Af : ℝ) |
| (P : Bool → ℝ → ℝ → Prop) (M : Bool → ℝ → ℝ → SeedProgram d) |
| (S Q : ℕ) (hM : ∀s r τ,P s r τ → (M s r τ).slots ≤ S ∧ (M s r τ).calls ≤ Q) |
| (E : MeanTree X d) (n : ℝ) (hr : RootShiftReady D A Af (P true) (P false) E n) : |
| (compileDeclaredRoot D A Af (M true) (M false) E n).slots ≤ 1+cost E*(S+1) ∧ |
| (compileDeclaredRoot D A Af (M true) (M false) E n).calls ≤ cost E*Q := by |
| cases E with | node k b hb a r C => |
| have hc (i) := compileDeclared_size D A (P false) (M false) S Q (hM false) (C i) (r i/(2*D)) (hr i).2.2 |
| have hm (i) := hM true (r i) (declaredNoise n Af) (hr i).2.1 |
| constructor |
| · simp only [compileDeclaredRoot,slots_compileTerms,Expression.slots,cost] |
| apply Nat.add_le_add_left |
| rw [Finset.sum_mul] |
| apply Finset.sum_le_sum |
| intro i _ |
| have h₁ := (hc i).1 |
| have h₂ := (hm i).1 |
| nlinarith |
| · simp only [compileDeclaredRoot,calls_compileTerms,Expression.calls,zero_add,cost,Finset.sum_mul] |
| apply Finset.sum_le_sum |
| intro i _ |
| have h₁ := (hc i).2 |
| have h₂ := (hm i).2 |
| nlinarith |
|
|
| theorem compileDeclaredRootShift_energy_bound {D A Af R B : ℝ} (hD : 0<D) (hR : 0≤R) (hB : 0≤B) |
| (P : Bool → ℝ → ℝ → Prop) (M : Bool → ℝ → ℝ → SeedProgram d) |
| (hv : ∀s r τ,P s r τ → (∑j,(M s r τ).shift j^2) ≤ D^2) |
| (hBv : ∀s r τ,P s r τ → (∑j,(M s r τ).shift j^2) ≤ B) |
| (E : MeanTree X d) (n : ℝ) (p : DriftData E) |
| (hr : RootShiftReady D A Af (P true) (P false) E n) (hg : DriftBound R E p) : |
| (∑j,compileDeclaredRootShift D A Af (M true) (M false) E n p j^2) ≤ (cost E:ℝ)*(4*R^2*B) := by |
| cases E with | node k b hb a r C => |
| change (∑j,compileTermsShift D k a (fun i => compileDeclared D A (M false) (C i) (r i/(2*D))) |
| (fun i => M true (r i) (declaredNoise n Af)) (.noise b hb (declaredReserve n Af a)) |
| (fun i => compileDeclaredShift D A (M false) (C i) (r i/(2*D)) (p.2 i)) |
| (fun i => inverseChildShift D (r i) ((p.2 i).root (C i)) (M true (r i) (declaredNoise n Af))) |
| (fun _ => 0) j^2) ≤ _ |
| rw [compileTermsShift_energy] |
| simp only [zero_pow (by decide : (2:ℕ)≠0),Finset.sum_const_zero,zero_add,cost,Nat.cast_sum,Nat.cast_add,Nat.cast_one,Finset.sum_mul] |
| apply Finset.sum_le_sum |
| intro i _ |
| have hc := compileDeclaredShift_energy_bound hD hR hB (P false) (M false) (hv false) (hBv false) |
| (C i) (r i/(2*D)) (p.2 i) (hr i).2.2 (hg i).2 |
| have hi := inverse_shift_energy (fun j => (M true (r i) (declaredNoise n Af)).shift j/(2*D)) |
| (M true (r i) (declaredNoise n Af)).shift (normalized_shift_bound hD _ (hv _ _ _ (hr i).2.1)) |
| (((p.2 i).root (C i))/(r i)) |
| have hs := hBv _ _ _ (hr i).2.1 |
| have hh : (((p.2 i).root (C i))/(r i))^2 ≤ R^2 := by |
| simpa only [sq_abs] using pow_le_pow_left₀ (abs_nonneg _) (hg i).1 2 |
| have hm := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hh (by norm_num : (0:ℝ)≤4)) hB |
| have hv' := mul_le_mul_of_nonneg_left hs (show 0≤4*(((p.2 i).root (C i))/(r i))^2 by positivity) |
| change (∑j,compileDeclaredShift D A (M false) (C i) (r i/(2*D)) (p.2 i) j^2)+ |
| (∑j,inverseChildShift D (r i) ((p.2 i).root (C i)) (M true (r i) (declaredNoise n Af)) j^2) ≤ _ |
| change (∑j,inverseChildShift D (r i) ((p.2 i).root (C i)) (M true (r i) (declaredNoise n Af)) j^2) ≤ _ at hi |
| nlinarith |
| end LogConcaveSampling.MeanTree |
| |
| end |
| |
| end |
| |
| end OAI |
| |
