math / data /lean /OAI /Algorithms /SubexponentialSAT /SqrtLogSpace /DisjointReuse /SparseBudget.lean
Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseBudget.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 26.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseBudget.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseBudget.lean
-
curl -L -o SparseBudget.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseBudget.lean
26.7 kB
| import OAI.Algorithms.SubexponentialSAT.BranchTree | |
| import OAI.Algorithms.SubexponentialSAT.Sunflower | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparsePriority | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseCharging | |
| import Mathlib.Algebra.Ring.GeomSum | |
| import Mathlib.Data.Nat.Log | |
| import Mathlib.Data.Nat.Find | |
| import Mathlib.Analysis.SpecialFunctions.Log.Base | |
| import Mathlib.Data.Rat.Cast.Order | |
| import Mathlib.Tactic.Linarith | |
| import Mathlib.Tactic.NormNum | |
| import Mathlib.Tactic.Ring | |
| /-! | |
| # Sharp numerical budgets for disjoint counting sparsification | |
| The frozen counting manuscript, Appendix A, lines 1991–2054. These numerical lemmas do not assert the | |
| existence of a sparsification tree or a primitive implementation. | |
| -/ | |
| namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseBudget | |
| open Finset | |
| open scoped BigOperators | |
| /-- The literal-degree sum in the source's leaf occurrence estimate. -/ | |
| def occurrenceCap (k M : ℕ) : ℕ := 2 * ∑ j ∈ range k, M ^ j | |
| theorem sum_pow_le_twice_last (M : ℕ) (hM : 2 ≤ M) (j : ℕ) : | |
| ∑ i ∈ range (j + 1), M ^ i ≤ 2 * M ^ j := by | |
| induction j with | |
| | zero => simp | |
| | succ j ih => | |
| rw [sum_range_succ] | |
| have hp : 2 * M ^ j ≤ M ^ (j + 1) := by | |
| rw [pow_succ] | |
| simpa [Nat.mul_comm] using Nat.mul_le_mul_right (M ^ j) hM | |
| omega | |
| theorem occurrenceCap_le (k M : ℕ) (hk : 0 < k) (hM : 2 ≤ M) : | |
| occurrenceCap k M ≤ 4 * M ^ (k - 1) := by | |
| obtain ⟨j, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hk) | |
| have h := sum_pow_le_twice_last M hM j | |
| dsimp [occurrenceCap] | |
| calc | |
| 2 * ∑ i ∈ range (j + 1), M ^ i ≤ 2 * (2 * M ^ j) := Nat.mul_le_mul_left 2 h | |
| _ = 4 * M ^ (j + 1 - 1) := by simp; ring | |
| /-- An explicit constant exponent absorbs the affine term in the dyadic test. -/ | |
| theorem control_exponent (a q γ : ℕ) : | |
| let T := 2 * (γ * (a + 4 * q + 1) + 1) | |
| 1 ≤ T ∧ γ ≤ 2 ^ T ∧ γ * (a + q * (T + 2)) ≤ 2 ^ T := by | |
| let u := γ * (a + 4 * q + 1) + 1 | |
| have hu : 1 ≤ u := by dsimp [u]; omega | |
| have hγ : γ ≤ u := by dsimp [u]; nlinarith | |
| have hconstant : γ * a + 2 * γ * q ≤ u := by dsimp [u]; nlinarith | |
| have hslope : 2 * γ * q + 1 ≤ u := by dsimp [u]; nlinarith | |
| have hp : u ≤ 2 ^ u := (Nat.lt_pow_self (by decide : 1 < 2)).le | |
| have hsquare : u ^ 2 ≤ 2 ^ (2 * u) := by | |
| calc | |
| u ^ 2 ≤ (2 ^ u) ^ 2 := Nat.pow_le_pow_left hp 2 | |
| _ = 2 ^ (2 * u) := by rw [← pow_mul, Nat.mul_comm] | |
| have hscaled := Nat.mul_le_mul_right u hslope | |
| have hlinear : γ * (a + q * (2 * u + 2)) ≤ u ^ 2 := by | |
| nlinarith | |
| refine ⟨by dsimp [u] at *; omega, ?_, hlinear.trans hsquare⟩ | |
| exact hγ.trans ((by nlinarith : u ≤ u ^ 2).trans hsquare) | |
| /-- A dyadic witness of order `s log s`, rather than the old quadratic witness. | |
| The source's test uses `clog 2 (4 C M)`, so every comparison is integral. -/ | |
| theorem dyadic_witness (C : ℕ → ℕ) (a q γ s : ℕ) (hs : 0 < s) | |
| (hC : ∀ M, 2 ≤ M → C M ≤ a * M ^ q) : | |
| ∃ T e : ℕ, 1 ≤ T ∧ γ ≤ 2 ^ e ∧ 2 ≤ 2 ^ e ∧ | |
| γ * Nat.clog 2 (4 * C (2 ^ e) * 2 ^ e) * s ≤ 2 ^ e ∧ | |
| 2 ^ e ≤ (4 * 2 ^ T) * s * (Nat.log 2 s + 1) ∧ | |
| e ≤ T + 2 * (Nat.log 2 s + 1) ∧ | |
| T = 2 * (γ * (a + 2 + 4 * (q + 1) + 1) + 1) := by | |
| let T := 2 * (γ * (a + 2 + 4 * (q + 1) + 1) + 1) | |
| let l := Nat.log 2 s + 1 | |
| let t := Nat.log 2 l + 1 | |
| let e := T + l + t | |
| obtain ⟨hT, hγT, hcontrol⟩ := control_exponent (a + 2) (q + 1) γ | |
| have hl : 0 < l := by dsimp [l]; omega | |
| have ht : t ≤ l := Nat.succ_le_of_lt (Nat.log_lt_self 2 (by omega)) | |
| have hslow : s ≤ 2 ^ l := (Nat.lt_pow_succ_log_self (by decide) s).le | |
| have hllow : l ≤ 2 ^ t := (Nat.lt_pow_succ_log_self (by decide) l).le | |
| have hsup : 2 ^ l ≤ 2 * s := by | |
| calc | |
| 2 ^ l = 2 ^ Nat.log 2 s * 2 := by rw [show l = Nat.log 2 s + 1 from rfl, pow_succ] | |
| _ ≤ s * 2 := Nat.mul_le_mul_right 2 (Nat.pow_log_le_self 2 (by omega)) | |
| _ = 2 * s := Nat.mul_comm _ _ | |
| have htup : 2 ^ t ≤ 2 * l := by | |
| calc | |
| 2 ^ t = 2 ^ Nat.log 2 l * 2 := by rw [show t = Nat.log 2 l + 1 from rfl, pow_succ] | |
| _ ≤ l * 2 := Nat.mul_le_mul_right 2 (Nat.pow_log_le_self 2 (by omega)) | |
| _ = 2 * l := Nat.mul_comm _ _ | |
| have he : 1 ≤ e := by dsimp [e, T] at *; omega | |
| have hM : 2 ≤ 2 ^ e := by | |
| simpa using Nat.pow_le_pow_right (by decide : 0 < 2) he | |
| have hcoeff : 4 * a ≤ 2 ^ (a + 2) := by | |
| calc | |
| 4 * a ≤ 4 * 2 ^ a := Nat.mul_le_mul_left 4 (Nat.lt_pow_self (by decide)).le | |
| _ = 2 ^ (a + 2) := by rw [pow_add]; norm_num; ring | |
| have hbase : 4 * C (2 ^ e) * 2 ^ e ≤ 2 ^ (a + 2 + (q + 1) * e) := by | |
| calc | |
| 4 * C (2 ^ e) * 2 ^ e ≤ 4 * (a * (2 ^ e) ^ q) * 2 ^ e := | |
| Nat.mul_le_mul_right _ (Nat.mul_le_mul_left _ (hC _ hM)) | |
| _ = (4 * a) * (2 ^ e) ^ (q + 1) := by rw [pow_succ]; ring | |
| _ ≤ 2 ^ (a + 2) * (2 ^ e) ^ (q + 1) := Nat.mul_le_mul_right _ hcoeff | |
| _ = 2 ^ (a + 2 + (q + 1) * e) := by | |
| rw [← pow_mul, ← pow_add, Nat.mul_comm e (q + 1)] | |
| have hlog : Nat.clog 2 (4 * C (2 ^ e) * 2 ^ e) ≤ a + 2 + (q + 1) * e := | |
| (Nat.le_pow_iff_clog_le (by decide)).mp hbase | |
| have htl : T ≤ T * l := Nat.le_mul_of_pos_right T hl | |
| have hal : a + 2 ≤ (a + 2) * l := Nat.le_mul_of_pos_right (a + 2) hl | |
| have het : e ≤ (T + 2) * l := by dsimp [e]; nlinarith | |
| have hbound : a + 2 + (q + 1) * e ≤ (a + 2 + (q + 1) * (T + 2)) * l := by | |
| have := Nat.mul_le_mul_left (q + 1) het | |
| nlinarith | |
| have hbudget : γ * Nat.clog 2 (4 * C (2 ^ e) * 2 ^ e) * s ≤ 2 ^ e := by | |
| calc | |
| γ * Nat.clog 2 (4 * C (2 ^ e) * 2 ^ e) * s ≤ | |
| γ * ((a + 2 + (q + 1) * (T + 2)) * l) * s := by | |
| exact Nat.mul_le_mul_right s (Nat.mul_le_mul_left γ (hlog.trans hbound)) | |
| _ = (γ * (a + 2 + (q + 1) * (T + 2))) * s * l := by ring | |
| _ ≤ 2 ^ T * s * l := by exact Nat.mul_le_mul_right l (Nat.mul_le_mul_right s hcontrol) | |
| _ ≤ 2 ^ T * 2 ^ l * 2 ^ t := Nat.mul_le_mul (Nat.mul_le_mul_left _ hslow) hllow | |
| _ = 2 ^ e := by | |
| calc | |
| 2 ^ T * 2 ^ l * 2 ^ t = 2 ^ (T + l) * 2 ^ t := | |
| congrArg (fun x : ℕ => x * 2 ^ t) (pow_add 2 T l).symm | |
| _ = 2 ^ e := (pow_add 2 (T + l) t).symm | |
| refine ⟨T, e, hT, ?_, hM, hbudget, ?_, ?_, rfl⟩ | |
| · exact hγT.trans (Nat.pow_le_pow_right (by decide) (by dsimp [e]; omega)) | |
| · calc | |
| 2 ^ e = 2 ^ T * 2 ^ l * 2 ^ t := by dsimp [e]; rw [pow_add, pow_add] | |
| _ ≤ 2 ^ T * (2 * s) * (2 * l) := Nat.mul_le_mul (Nat.mul_le_mul_left _ hsup) htup | |
| _ = (4 * 2 ^ T) * s * (Nat.log 2 s + 1) := by dsimp [l]; ring | |
| · dsimp [e]; omega | |
| open SparseCharging | |
| theorem depthConstant_le (k M : ℕ) (hM : 2 ≤ M) : | |
| depthConstant k M ≤ (4 * (k - 1) * 3 ^ (k - 2)) * M ^ (k - 2) := by | |
| have hsum : (∑ j ∈ range (k - 1), (3 * M) ^ j) ≤ | |
| (k - 1) * (3 * M) ^ (k - 2) := by | |
| calc | |
| _ ≤ ∑ _j ∈ range (k - 1), (3 * M) ^ (k - 2) := by | |
| apply sum_le_sum | |
| intro j hj | |
| exact Nat.pow_le_pow_right (by omega) (by have := mem_range.mp hj; omega) | |
| _ = _ := by simp | |
| calc | |
| depthConstant k M ≤ 4 * ((k - 1) * (3 * M) ^ (k - 2)) := Nat.mul_le_mul_left _ hsum | |
| _ = _ := by rw [mul_pow]; ring | |
| /-- Exact source test at the candidate `M = 2^e`, for the rational numerator `a` | |
| and denominator `b`. Only integer arithmetic and a ceiling logarithm occur. -/ | |
| def parameterTest (k a b e : ℕ) : Bool := | |
| decide (2 ≤ 2 ^ e ∧ rightConstant k ≤ 2 ^ e ∧ | |
| rightConstant k * Nat.clog 2 (4 * depthConstant k (2 ^ e) * 2 ^ e) * b ≤ | |
| a * 2 ^ e) | |
| /-- Conservative inverse of a positive rational budget. -/ | |
| def inverseIndex (a b : ℕ) : ℕ := (b - 1) / a + 1 | |
| theorem inverseIndex_mul (a b : ℕ) (ha : 0 < a) : b ≤ a * inverseIndex a b := by | |
| have := Nat.lt_mul_div_succ (b - 1) ha | |
| dsimp [inverseIndex] | |
| omega | |
| /-- The search terminates, with a fully explicit coefficient depending only on | |
| `k`. This theorem counts candidates; primitive bit costs are proved separately. -/ | |
| theorem exists_parameter (k a b : ℕ) (ha : 0 < a) : | |
| ∃ e, parameterTest k a b e = true := by | |
| let s := inverseIndex a b | |
| obtain ⟨T, e, _, hγ, hM, hbudget, _, _, _⟩ := | |
| dyadic_witness (depthConstant k) (4 * (k - 1) * 3 ^ (k - 2)) (k - 2) | |
| (rightConstant k) s (by exact Nat.zero_lt_succ _) | |
| (fun M hM => depthConstant_le k M hM) | |
| refine ⟨e, ?_⟩ | |
| simp only [parameterTest, decide_eq_true_eq] | |
| refine ⟨hM, hγ, ?_⟩ | |
| calc | |
| rightConstant k * Nat.clog 2 (4 * depthConstant k (2 ^ e) * 2 ^ e) * b ≤ | |
| rightConstant k * Nat.clog 2 (4 * depthConstant k (2 ^ e) * 2 ^ e) * (a * s) := | |
| Nat.mul_le_mul_left _ (inverseIndex_mul a b ha) | |
| _ = a * (rightConstant k * Nat.clog 2 (4 * depthConstant k (2 ^ e) * 2 ^ e) * s) := by ring | |
| _ ≤ a * 2 ^ e := Nat.mul_le_mul_left a hbudget | |
| /-- First passing power of two in the source's deterministic search. -/ | |
| def chooseExponent (k a b : ℕ) (ha : 0 < a) : ℕ := Nat.find (exists_parameter k a b ha) | |
| def chooseM (k a b : ℕ) (ha : 0 < a) : ℕ := 2 ^ chooseExponent k a b ha | |
| theorem chooseExponent_spec (k a b : ℕ) (ha : 0 < a) : | |
| parameterTest k a b (chooseExponent k a b ha) = true := | |
| Nat.find_spec (exists_parameter k a b ha) | |
| theorem chooseExponent_le (k a b e : ℕ) (ha : 0 < a) | |
| (he : parameterTest k a b e = true) : chooseExponent k a b ha ≤ e := | |
| Nat.find_min' (exists_parameter k a b ha) he | |
| theorem chooseM_spec (k a b : ℕ) (ha : 0 < a) : | |
| 2 ≤ chooseM k a b ha ∧ rightConstant k ≤ chooseM k a b ha ∧ | |
| rightConstant k * Nat.clog 2 (4 * depthConstant k (chooseM k a b ha) * | |
| chooseM k a b ha) * b ≤ a * chooseM k a b ha := by | |
| simpa only [parameterTest, chooseM, decide_eq_true_eq] using chooseExponent_spec k a b ha | |
| /-- The first successful candidate inherits the sharp witness bound. Constants | |
| are chosen before the rational budget numerator and denominator. -/ | |
| theorem choose_bounds (k : ℕ) : | |
| ∃ K T : ℕ, ∀ a b (ha : 0 < a), | |
| chooseM k a b ha ≤ K * inverseIndex a b * (Nat.log 2 (inverseIndex a b) + 1) ∧ | |
| chooseExponent k a b ha ≤ T + 2 * (Nat.log 2 (inverseIndex a b) + 1) := by | |
| let A := 4 * (k - 1) * 3 ^ (k - 2) | |
| let q := k - 2 | |
| let T := 2 * (rightConstant k * (A + 2 + 4 * (q + 1) + 1) + 1) | |
| refine ⟨4 * 2 ^ T, T, ?_⟩ | |
| intro a b ha | |
| let s := inverseIndex a b | |
| obtain ⟨T', e, _, hγ, hM, hbudget, hsize, hindex, hT⟩ := | |
| dyadic_witness (depthConstant k) A q (rightConstant k) s | |
| (by exact Nat.zero_lt_succ _) (fun M hM => depthConstant_le k M hM) | |
| have he : parameterTest k a b e = true := by | |
| simp only [parameterTest, decide_eq_true_eq] | |
| refine ⟨hM, hγ, ?_⟩ | |
| calc | |
| rightConstant k * Nat.clog 2 (4 * depthConstant k (2 ^ e) * 2 ^ e) * b ≤ | |
| rightConstant k * Nat.clog 2 (4 * depthConstant k (2 ^ e) * 2 ^ e) * (a * s) := | |
| Nat.mul_le_mul_left _ (inverseIndex_mul a b ha) | |
| _ = a * (rightConstant k * Nat.clog 2 (4 * depthConstant k (2 ^ e) * 2 ^ e) * s) := by ring | |
| _ ≤ a * 2 ^ e := Nat.mul_le_mul_left a hbudget | |
| have hmin := chooseExponent_le k a b e ha he | |
| have hT' : T' = T := hT | |
| subst T' | |
| exact ⟨(Nat.pow_le_pow_right (by decide) hmin).trans hsize, hmin.trans hindex⟩ | |
| /-- The ceiling-log test implies the real exponent budget without a numerical | |
| logarithm oracle. -/ | |
| theorem chooseM_log_budget (k a b : ℕ) (ha : 0 < a) (hb : 0 < b) : | |
| (rightConstant k : ℝ) / chooseM k a b ha * | |
| Real.logb 2 (4 * (depthConstant k (chooseM k a b ha) : ℝ) * chooseM k a b ha) ≤ | |
| (a : ℝ) / b := by | |
| let M := chooseM k a b ha | |
| obtain ⟨hM, _, htest⟩ := chooseM_spec k a b ha | |
| have hMr : (0 : ℝ) < M := by exact_mod_cast (show 0 < M by dsimp [M]; omega) | |
| have hbr : (0 : ℝ) < b := by exact_mod_cast hb | |
| have hceil : Real.logb 2 (4 * (depthConstant k M : ℝ) * M) ≤ | |
| (Nat.clog 2 (4 * depthConstant k M * M) : ℝ) := by | |
| have h := Nat.le_ceil (Real.logb (2 : ℕ) (4 * depthConstant k M * M : ℕ)) | |
| rw [Real.natCeil_logb_natCast 2 (4 * depthConstant k M * M)] at h | |
| simpa using h | |
| have ht : (rightConstant k : ℝ) * Nat.clog 2 (4 * depthConstant k M * M) * b ≤ | |
| (a : ℝ) * M := by exact_mod_cast htest | |
| have hmul := mul_le_mul_of_nonneg_left hceil (by positivity : (0 : ℝ) ≤ rightConstant k) | |
| rw [div_mul_eq_mul_div] | |
| apply (div_le_div_iff₀ hMr hbr).mpr | |
| calc | |
| (rightConstant k : ℝ) * Real.logb 2 (4 * (depthConstant k M : ℝ) * M) * b ≤ | |
| (rightConstant k : ℝ) * Nat.clog 2 (4 * depthConstant k M * M) * b := | |
| mul_le_mul_of_nonneg_right hmul (by positivity) | |
| _ ≤ (a : ℝ) * M := ht | |
| theorem inverseIndex_le (a b : ℕ) (ha : 0 < a) : | |
| (inverseIndex a b : ℝ) ≤ (b : ℝ) / a + 1 := by | |
| have har : (0 : ℝ) < a := by exact_mod_cast ha | |
| have hdiv : (((b - 1) / a : ℕ) : ℝ) ≤ (b : ℝ) / a := by | |
| apply (le_div_iff₀ har).mpr | |
| exact_mod_cast (Nat.div_mul_le_self (b - 1) a).trans (Nat.sub_le b 1) | |
| simpa [inverseIndex] using add_le_add_right hdiv 1 | |
| /-- Sharp source asymptotics, with constants independent of both numerator and | |
| denominator. The logarithm is real base two. -/ | |
| theorem chooseM_real_bound (k : ℕ) : | |
| ∃ K : ℝ, 0 < K ∧ ∀ a b (ha : 0 < a), a ≤ b → | |
| (chooseM k a b ha : ℝ) ≤ K * ((b : ℝ) / a) * Real.logb 2 (2 * ((b : ℝ) / a)) := by | |
| obtain ⟨K, T, hK⟩ := choose_bounds k | |
| refine ⟨4 * (K + 1), by positivity, ?_⟩ | |
| intro a b ha hab | |
| let r : ℝ := (b : ℝ) / a | |
| let s := inverseIndex a b | |
| have har : (0 : ℝ) < a := by exact_mod_cast ha | |
| have hr : 1 ≤ r := by | |
| dsimp [r] | |
| exact (le_div_iff₀ har).mpr (by simpa using (Nat.cast_le (α := ℝ)).mpr hab) | |
| have hs : (0 : ℝ) < s := by dsimp [s, inverseIndex]; positivity | |
| have hsbound : (s : ℝ) ≤ 2 * r := by | |
| have := inverseIndex_le a b ha | |
| dsimp [s, r] at * | |
| linarith | |
| have hlog : (Nat.log 2 s : ℝ) ≤ Real.logb 2 (2 * r) := | |
| (Real.natLog_le_logb s 2).trans (Real.logb_le_logb_of_le (by norm_num) hs hsbound) | |
| have hlogone : 1 ≤ Real.logb 2 (2 * r) := by | |
| have h := Real.logb_le_logb_of_le (b := 2) (by norm_num) (by norm_num : (0 : ℝ) < 2) | |
| (show (2 : ℝ) ≤ 2 * r by linarith) | |
| simpa using h | |
| have hlogsum : (Nat.log 2 s : ℝ) + 1 ≤ 2 * Real.logb 2 (2 * r) := by linarith | |
| have hsize : (chooseM k a b ha : ℝ) ≤ (K : ℝ) * s * ((Nat.log 2 s : ℝ) + 1) := by | |
| exact_mod_cast (hK a b ha).1 | |
| calc | |
| (chooseM k a b ha : ℝ) ≤ (K : ℝ) * s * ((Nat.log 2 s : ℝ) + 1) := hsize | |
| _ ≤ (K : ℝ) * (2 * r) * (2 * Real.logb 2 (2 * r)) := by | |
| apply mul_le_mul | |
| · exact mul_le_mul_of_nonneg_left hsbound (by positivity) | |
| · exact hlogsum | |
| · positivity | |
| · positivity | |
| _ ≤ 4 * (K + 1) * r * Real.logb 2 (2 * r) := by | |
| nlinarith [mul_nonneg (by linarith : 0 ≤ r) (by linarith : 0 ≤ Real.logb 2 (2 * r))] | |
| theorem rational_data (σ : ℚ) (hσ : 0 < σ) : | |
| 0 < σ.num.natAbs ∧ (σ.num.natAbs : ℝ) / σ.den = (σ : ℝ) := by | |
| have hnum : 0 < σ.num := Rat.num_pos.mpr hσ | |
| have habs : (σ.num.natAbs : ℤ) = σ.num := Int.natAbs_of_nonneg hnum.le | |
| refine ⟨Int.natAbs_pos.mpr (ne_of_gt hnum), ?_⟩ | |
| rw [Rat.cast_def] | |
| congr 1 | |
| simpa only [Int.cast_natCast] using congrArg (fun z : ℤ => (z : ℝ)) habs | |
| /-- The source selector on a positive rational budget, preserving its exact | |
| numerator and denominator in every comparison. -/ | |
| def chooseForSigma (k : ℕ) (σ : ℚ) (hσ : 0 < σ) : ℕ := | |
| chooseM k σ.num.natAbs σ.den (rational_data σ hσ).1 | |
| theorem chooseForSigma_reciprocal (k s : ℕ) (hs : 0 < s) | |
| (hσ : (0 : ℚ) < 1 / s) : | |
| chooseForSigma k (1 / s) hσ = chooseM k 1 s (by decide) := by | |
| have hn : ((1 : ℚ) / s).num = 1 := by | |
| simpa only [Int.cast_one, Int.cast_natCast] using | |
| Rat.num_div_eq_of_coprime (a := 1) (b := (s : ℤ)) | |
| (by exact_mod_cast hs) (by simp) | |
| have hd : ((1 : ℚ) / s).den = s := by | |
| have hd' : (((1 : ℚ) / s).den : ℤ) = (s : ℤ) := by | |
| simpa only [Int.cast_one, Int.cast_natCast] using Rat.den_div_eq_of_coprime | |
| (a := 1) (b := (s : ℤ)) (by exact_mod_cast hs) (by simp) | |
| exact_mod_cast hd' | |
| simp only [chooseForSigma, hn, hd, Int.natAbs_one] | |
| theorem chooseForSigma_log_budget (k : ℕ) (σ : ℚ) (hσ : 0 < σ) : | |
| (rightConstant k : ℝ) / chooseForSigma k σ hσ * | |
| Real.logb 2 (4 * (depthConstant k (chooseForSigma k σ hσ) : ℝ) * | |
| chooseForSigma k σ hσ) ≤ (σ : ℝ) := by | |
| simpa only [chooseForSigma, (rational_data σ hσ).2] using | |
| chooseM_log_budget k σ.num.natAbs σ.den (rational_data σ hσ).1 σ.pos | |
| theorem chooseForSigma_sharp (k : ℕ) : | |
| ∃ K : ℝ, 0 < K ∧ ∀ (σ : ℚ) (hσ : 0 < σ), σ ≤ 1 → | |
| (chooseForSigma k σ hσ : ℝ) ≤ | |
| K * (σ : ℝ)⁻¹ * Real.logb 2 (2 / (σ : ℝ)) := by | |
| obtain ⟨K, hK, hbound⟩ := chooseM_real_bound k | |
| refine ⟨K, hK, ?_⟩ | |
| intro σ hσ hσone | |
| have hdata := rational_data σ hσ | |
| have hden : (0 : ℝ) < σ.den := by exact_mod_cast σ.pos | |
| have hσreal : (σ : ℝ) ≤ 1 := by exact_mod_cast hσone | |
| have hab : σ.num.natAbs ≤ σ.den := by | |
| rw [← hdata.2, div_le_one hden] at hσreal | |
| exact_mod_cast hσreal | |
| have hinv : (σ.den : ℝ) / σ.num.natAbs = (σ : ℝ)⁻¹ := by | |
| rw [← hdata.2, inv_div] | |
| simpa only [chooseForSigma, hinv, div_eq_mul_inv] using | |
| hbound σ.num.natAbs σ.den hdata.1 hab | |
| /-- The source's explicit node bound for a tree with the charged path budgets. | |
| It applies to an actual finite tree and includes every internal node. -/ | |
| theorem nodeCount_le (t : BranchTree.Tree) (C γ n M : ℕ) (σ : ℝ) | |
| (hC : 1 ≤ C) (hγ : 1 ≤ γ) (hγM : γ ≤ M) | |
| (hbudget : (γ : ℝ) / M * Real.logb 2 (4 * (C : ℝ) * M) ≤ σ) | |
| (hdepth : ∀ p ∈ t.paths, p.length ≤ C * n) | |
| (hB : ∀ p ∈ t.paths, p.count true ≤ γ * n / M) : | |
| (t.nodeCount : ℝ) ≤ ((C * n + 1 : ℕ) : ℝ) ^ 2 * (2 : ℝ) ^ (σ * n) := by | |
| have hpositions : ∀ p ∈ t.paths, (BranchTree.bPositions p).card ≤ γ * n / M := by | |
| intro p hp | |
| rw [BranchTree.card_bPositions_eq_count] | |
| exact hB p hp | |
| have hM : (0 : ℝ) < M := by exact_mod_cast (show 0 < M by omega) | |
| have hγpos : (0 : ℝ) < γ := by exact_mod_cast (show 0 < γ by omega) | |
| have hγone : (1 : ℝ) ≤ γ := by exact_mod_cast hγ | |
| have hCpos : (0 : ℝ) < C := by exact_mod_cast (show 0 < C by omega) | |
| have hdim : (γ : ℝ) / M ≤ C := by | |
| have hquot : (γ : ℝ) / M ≤ 1 := (div_le_one hM).mpr (by exact_mod_cast hγM) | |
| exact hquot.trans (by exact_mod_cast hC) | |
| by_cases hn : n = 0 | |
| · subst n | |
| have ht := t.nodeCount_le (C * 0) (γ * 0 / M) hdepth hpositions | |
| have ht' : t.nodeCount ≤ 1 := by simpa using ht | |
| simpa using (Nat.cast_le (α := ℝ)).mpr ht' | |
| have hnpos : (0 : ℝ) < n := by exact_mod_cast (Nat.pos_of_ne_zero hn) | |
| let q : ℝ := (γ : ℝ) * n / M | |
| have hq : 0 < q := by dsimp [q]; positivity | |
| have hD : q ≤ (C * n : ℕ) := by | |
| have h := mul_le_mul_of_nonneg_right hdim hnpos.le | |
| simpa [q, Nat.cast_mul, div_mul_eq_mul_div] using h | |
| have hR : ((γ * n / M : ℕ) : ℝ) ≤ q := by | |
| simpa [q, Nat.cast_mul] using (Nat.cast_div_le (m := γ * n) (n := M) (α := ℝ)) | |
| have hbase : 4 * ((C * n : ℕ) : ℝ) / q = 4 * (C : ℝ) * M / γ := by | |
| dsimp [q] | |
| push_cast | |
| field_simp | |
| have hlog : Real.logb 2 (4 * (C : ℝ) * M / γ) ≤ Real.logb 2 (4 * (C : ℝ) * M) := by | |
| apply Real.logb_le_logb_of_le (by norm_num) (by positivity) | |
| exact div_le_self (by positivity) hγone | |
| have hb : (γ : ℝ) / M * Real.log (4 * (C : ℝ) * M / γ) ≤ Real.log 2 * σ := by | |
| have hh := (mul_le_mul_of_nonneg_left hlog | |
| (by positivity : (0 : ℝ) ≤ (γ : ℝ) / M)).trans hbudget | |
| rw [Real.logb, ← mul_div_assoc, div_le_iff₀ (Real.log_pos (by norm_num : (1 : ℝ) < 2))] at hh | |
| simpa [mul_comm] using hh | |
| have hbudget' : q * Real.log (4 * ((C * n : ℕ) : ℝ) / q) ≤ Real.log 2 * (σ * n) := by | |
| rw [hbase] | |
| have hh := mul_le_mul_of_nonneg_right hb hnpos.le | |
| convert hh using 1 <;> (try dsimp [q]) <;> ring | |
| have ht := BranchTree.card_paths_le_two_rpow t.paths (C * n) (γ * n / M) | |
| hq hD hR hdepth hpositions hbudget' | |
| rw [t.card_paths] at ht | |
| have hquot : γ * n / M ≤ C * n := by | |
| calc | |
| γ * n / M ≤ n := Nat.div_le_of_le_mul (by | |
| simpa [Nat.mul_comm] using Nat.mul_le_mul_right n hγM) | |
| _ ≤ C * n := by nlinarith | |
| have hquotr : ((γ * n / M : ℕ) : ℝ) + 1 ≤ (C * n : ℕ) + 1 := by | |
| exact_mod_cast Nat.add_le_add_right hquot 1 | |
| refine ht.trans (mul_le_mul_of_nonneg_right ?_ (Real.rpow_nonneg (by norm_num) _)) | |
| simpa only [Nat.cast_add, Nat.cast_one, pow_two] using | |
| mul_le_mul_of_nonneg_left hquotr (by positivity : (0 : ℝ) ≤ (C * n : ℕ) + 1) | |
| theorem four_le_depthConstant (k M : ℕ) (hk : 2 ≤ k) : 4 ≤ depthConstant k M := by | |
| have hsum : 1 ≤ ∑ j ∈ range (k - 1), (3 * M) ^ j := by | |
| simpa using (Finset.single_le_sum (f := fun j => (3 * M) ^ j) | |
| (fun _ _ => Nat.zero_le _) (show 0 ∈ range (k - 1) from mem_range.mpr (by omega))) | |
| exact Nat.mul_le_mul_left 4 hsum | |
| theorem four_le_rightConstant (k : ℕ) (hk : 2 ≤ k) : 4 ≤ rightConstant k := by | |
| simpa [depthConstant, rightConstant] using four_le_depthConstant k 1 hk | |
| theorem selected_nodeCount_le (t : BranchTree.Tree) (k n : ℕ) (σ : ℚ) | |
| (hk : 2 ≤ k) (hσ : 0 < σ) | |
| (hdepth : ∀ p ∈ t.paths, p.length ≤ depthConstant k (chooseForSigma k σ hσ) * n) | |
| (hB : ∀ p ∈ t.paths, p.count true ≤ rightConstant k * n / chooseForSigma k σ hσ) : | |
| (t.nodeCount : ℝ) ≤ | |
| ((depthConstant k (chooseForSigma k σ hσ) * n + 1 : ℕ) : ℝ) ^ 2 * | |
| (2 : ℝ) ^ ((σ : ℝ) * n) := by | |
| have hspec := chooseM_spec k σ.num.natAbs σ.den (rational_data σ hσ).1 | |
| exact nodeCount_le t (depthConstant k (chooseForSigma k σ hσ)) (rightConstant k) | |
| n (chooseForSigma k σ hσ) σ | |
| (by have := four_le_depthConstant k (chooseForSigma k σ hσ) hk; omega) | |
| (by have := four_le_rightConstant k hk; omega) hspec.2.1 | |
| (chooseForSigma_log_budget k σ hσ) hdepth hB | |
| /-- Terminality of the actual priority selector gives the sharp occurrence cap. | |
| Unused variables contribute zero occurrences and are retained in the ambient type. -/ | |
| theorem leaf_occurrences_le {n : ℕ} (F : SAT.CNF (Fin n)) (k M : ℕ) | |
| (hM : 2 ≤ M) (hWidth : ∀ C ∈ F, C.card ≤ k) | |
| (hTerminal : SparsePriority.select F M = none) : | |
| ∀ v, SAT.occurrences v F ≤ occurrenceCap k M := by | |
| apply Sunflower.variable_occurrence_le_of_literal_bound F | |
| (∑ j ∈ range k, M ^ j) | |
| intro x | |
| calc | |
| (F.filter (fun C => x ∈ C)).card ≤ | |
| ∑ j ∈ range (k + 1), if j = 0 then 0 else M ^ (j - 1) := by | |
| apply Sunflower.literal_total_occurrence_le F k _ x hWidth | |
| intro j _ | |
| rcases j with _ | j | |
| · have hempty : F.filter (fun C => C.card = 0 ∧ x ∈ C) = ∅ := by | |
| apply Finset.eq_empty_iff_forall_notMem.mpr | |
| intro C hC | |
| obtain ⟨_, hc, hx⟩ := Finset.mem_filter.mp hC | |
| rw [Finset.card_eq_zero.mp hc] at hx | |
| simp at hx | |
| rw [hempty] | |
| simp | |
| · cases j with | |
| | zero => simpa using Sunflower.unit_literal_occurrence_le F x | |
| | succ j => | |
| have hd := SparsePriority.select_none_degree_lt (F := F) (M := M) | |
| (c := j + 1 + 1) (H := {x}) (by omega) hTerminal (by simp) (by simp) | |
| simpa [SparsePriority.degree, DisjointBranch.selected] using hd.le | |
| _ = ∑ j ∈ range k, M ^ j := by rw [Finset.sum_range_succ']; simp | |
| theorem leaf_occurrences_le_power {n : ℕ} (F : SAT.CNF (Fin n)) (k M : ℕ) | |
| (hk : 0 < k) (hM : 2 ≤ M) (hWidth : ∀ C ∈ F, C.card ≤ k) | |
| (hTerminal : SparsePriority.select F M = none) : | |
| ∀ v, SAT.occurrences v F ≤ 4 * M ^ (k - 1) := by | |
| intro v | |
| exact (leaf_occurrences_le F k M hM hWidth hTerminal v).trans (occurrenceCap_le k M hk hM) | |
| /-- Concrete finite scanning of the exact Boolean tests. This counts test calls, | |
| not primitive bit operations. -/ | |
| theorem choose_finite_scan (k a b : ℕ) (ha : 0 < a) : | |
| ParameterOrder.scanFrom (parameterTest k a b) 0 (chooseExponent k a b ha + 1) = | |
| (some (chooseExponent k a b ha), chooseExponent k a b ha + 1) := by | |
| simpa only [ParameterOrder.select, chooseExponent] using | |
| ParameterOrder.select_bounded_execution (parameterTest k a b) (exists_parameter k a b ha) | |
| (chooseExponent_spec k a b ha) | |
| theorem inverseIndex_le_denominator (a b : ℕ) (hb : 0 < b) : inverseIndex a b ≤ b := by | |
| have := Nat.div_le_self (b - 1) a | |
| dsimp [inverseIndex] | |
| omega | |
| /-- Search length is logarithmic in the positive rational denominator; candidate | |
| values remain polynomial in it. This exposes the uniform parameter-size budget. -/ | |
| theorem choose_encoding_bounds (k : ℕ) : | |
| ∃ K T : ℕ, ∀ a b (ha : 0 < a), 0 < b → | |
| chooseM k a b ha ≤ K * b ^ 2 ∧ | |
| chooseExponent k a b ha ≤ T + 2 * (Nat.log 2 b + 1) := by | |
| obtain ⟨K, T, h⟩ := choose_bounds k | |
| refine ⟨K, T, ?_⟩ | |
| intro a b ha hb | |
| have hs := inverseIndex_le_denominator a b hb | |
| have hlog : Nat.log 2 (inverseIndex a b) + 1 ≤ inverseIndex a b := | |
| Nat.succ_le_of_lt (Nat.log_lt_self 2 (by exact Nat.succ_ne_zero _)) | |
| constructor | |
| · calc | |
| chooseM k a b ha ≤ K * inverseIndex a b * (Nat.log 2 (inverseIndex a b) + 1) := | |
| (h a b ha).1 | |
| _ ≤ K * b * b := Nat.mul_le_mul (Nat.mul_le_mul_left K hs) (hlog.trans hs) | |
| _ = K * b ^ 2 := by ring | |
| · exact (h a b ha).2.trans (by have := Nat.log_mono_right (b := 2) hs; omega) | |
| /-- Discharge the numeric path premises from actual priority-selected paths. -/ | |
| theorem selectedPaths_nodeCount_le {n : ℕ} (t : BranchTree.Tree) | |
| (F : SAT.CNF (Fin n)) (k : ℕ) (σ : ℚ) (hk : 2 ≤ k) (hσ : 0 < σ) | |
| (hanti : SunflowerBranch.Antichain F) | |
| (hnt : ∀ C ∈ F, ¬ C.IsTautology) (hwidth : SAT.WidthAtMost k F) | |
| (hpaths : ∀ p ∈ t.paths, ∃ G, SelectedPath (chooseForSigma k σ hσ) F p G) : | |
| (t.nodeCount : ℝ) ≤ | |
| ((depthConstant k (chooseForSigma k σ hσ) * n + 1 : ℕ) : ℝ) ^ 2 * | |
| (2 : ℝ) ^ ((σ : ℝ) * n) := by | |
| have hM : 2 ≤ chooseForSigma k σ hσ := | |
| (chooseM_spec k σ.num.natAbs σ.den (rational_data σ hσ).1).1 | |
| apply selected_nodeCount_le t k n σ hk hσ | |
| · intro p hp | |
| obtain ⟨G, hG⟩ := hpaths p hp | |
| exact hG.length_le hM hanti hnt hwidth | |
| · intro p hp | |
| obtain ⟨G, hG⟩ := hpaths p hp | |
| exact (Nat.le_div_iff_mul_le (by omega)).mpr | |
| (hG.count_true_mul_le hM hanti hnt hwidth) | |
| end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseBudget | |