introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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