introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
28.7 kB
import Mathlib.Algebra.Ring.GeomSum
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Tactic.Ring
import Lean.Elab.Tactic.Omega
import OAI.Algorithms.SubexponentialSAT.RemovalCharging
import OAI.Algorithms.SubexponentialSAT.BranchTree
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparsePriority
/-! Appendix A, insertion recurrence and the resulting path budgets. -/
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseCharging
open scoped BigOperators
section FiniteCharging
variable {α : Type*} [DecidableEq α]
/-- Charge each removed marked clause to an inserted strict subset. Fibers may
overlap; their width-sensitive bounds are precisely those from marked priority. -/
theorem removed_card_le (marked removed inserted : Finset (Finset α)) (j M : ℕ)
(hremoved : removed ⊆ marked)
(hnonempty : ∀ Q ∈ inserted, Q.Nonempty)
(hcharge : ∀ C ∈ removed, ∃ Q ∈ inserted, Q ⊂ C)
(hdegree : ∀ Q ∈ inserted, 0 < Q.card → Q.card < j →
(marked.filter fun C => C.card = j ∧ Q ⊆ C).card ≤ 2 * M ^ (j - Q.card)) :
(removed.filter fun C => C.card = j).card ≤
2 * ∑ i ∈ Finset.range j,
M ^ (j - i) * (inserted.filter fun Q => Q.card = i).card := by
let s := removed.filter fun C => C.card = j
let t := inserted.filter fun Q => Q.card < j
have hcover : s ⊆ t.biUnion (fun Q => s.filter fun C => Q ⊆ C) := by
intro C hC
obtain ⟨hCR, hCj⟩ := Finset.mem_filter.mp hC
obtain ⟨Q, hQI, hQC⟩ := hcharge C hCR
apply Finset.mem_biUnion.mpr
exact ⟨Q, Finset.mem_filter.mpr ⟨hQI, hCj ▸ Finset.card_lt_card hQC⟩,
Finset.mem_filter.mpr ⟨hC, (Finset.ssubset_iff_subset_ne.mp hQC).1⟩⟩
have hfiber : ∀ Q ∈ t, (s.filter fun C => Q ⊆ C).card ≤ 2 * M ^ (j - Q.card) := by
intro Q hQ
obtain ⟨hQI, hQj⟩ := Finset.mem_filter.mp hQ
apply le_trans _ (hdegree Q hQI (hnonempty Q hQI).card_pos hQj)
apply Finset.card_le_card
intro C hC
obtain ⟨hCs, hQC⟩ := Finset.mem_filter.mp hC
obtain ⟨hCR, hCj⟩ := Finset.mem_filter.mp hCs
exact Finset.mem_filter.mpr ⟨hremoved hCR, hCj, hQC⟩
calc
s.card ≤ (t.biUnion fun Q => s.filter fun C => Q ⊆ C).card :=
Finset.card_le_card hcover
_ ≤ ∑ Q ∈ t, (s.filter fun C => Q ⊆ C).card := Finset.card_biUnion_le
_ ≤ ∑ Q ∈ t, 2 * M ^ (j - Q.card) := Finset.sum_le_sum hfiber
_ = 2 * ∑ i ∈ Finset.range j,
M ^ (j - i) * (inserted.filter fun Q => Q.card = i).card := by
have h := Finset.sum_fiberwise_eq_sum_filter' inserted (Finset.range j)
Finset.card (fun i => 2 * M ^ (j - i))
simp only [Finset.mem_range] at h
change (∑ Q ∈ inserted.filter (fun Q => Q.card < j), 2 * M ^ (j - Q.card)) = _
rw [← h, Finset.mul_sum]
apply Finset.sum_congr rfl
intro i _
simp [mul_assoc, mul_comm, mul_left_comm]
end FiniteCharging
def depthConstant (k M : ℕ) : ℕ :=
4 * ∑ j ∈ Finset.range (k - 1), (3 * M) ^ j
def rightConstant (k : ℕ) : ℕ :=
4 * ∑ j ∈ Finset.range (k - 1), 3 ^ j
/-- The recurrence in source equation `spar-insertions`, indexed from width one. -/
theorem insertion_le (M n k : ℕ) (N : ℕ → ℕ)
(hrec : ∀ j < k - 1,
N (j + 1) ≤ 4 * n * M ^ j +
2 * ∑ i ∈ Finset.range j, M ^ (j - i) * N (i + 1)) :
∀ j < k - 1, N (j + 1) ≤ 4 * (3 * M) ^ j * n := by
intro j
induction j using Nat.strong_induction_on with
| h j ih =>
intro hj
have hsum : (∑ i ∈ Finset.range j, M ^ (j - i) * N (i + 1)) ≤
4 * n * M ^ j * ∑ i ∈ Finset.range j, 3 ^ i := by
calc
_ ≤ ∑ i ∈ Finset.range j, M ^ (j - i) * (4 * (3 * M) ^ i * n) := by
apply Finset.sum_le_sum
intro i hi
exact Nat.mul_le_mul_left _
(ih i (Finset.mem_range.mp hi) ((Finset.mem_range.mp hi).trans hj))
_ = 4 * n * M ^ j * ∑ i ∈ Finset.range j, 3 ^ i := by
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro i hi
have hpow : M ^ (j - i) * M ^ i = M ^ j := by
rw [← pow_add, Nat.sub_add_cancel (Nat.le_of_lt (Finset.mem_range.mp hi))]
rw [mul_pow]
calc
_ = 4 * n * (M ^ (j - i) * M ^ i) * 3 ^ i := by ring
_ = _ := by rw [hpow]
have hgeom : (∑ i ∈ Finset.range j, 3 ^ i) * 2 + 1 = 3 ^ j :=
geom_sum_mul_add (2 : ℕ) j
calc
N (j + 1) ≤ 4 * n * M ^ j +
2 * ∑ i ∈ Finset.range j, M ^ (j - i) * N (i + 1) := hrec j hj
_ ≤ 4 * n * M ^ j +
2 * (4 * n * M ^ j * ∑ i ∈ Finset.range j, 3 ^ i) :=
Nat.add_le_add_left (Nat.mul_le_mul_left 2 hsum) _
_ = 4 * n * M ^ j * ((∑ i ∈ Finset.range j, 3 ^ i) * 2 + 1) := by ring
_ = 4 * (3 * M) ^ j * n := by rw [hgeom, mul_pow]; ring
/-- Every edge inserts at least one clause; summing the sharp per-width bounds
therefore bounds a path's number of edges. -/
theorem depth_le (M n k T : ℕ) (N : ℕ → ℕ)
(hsteps : T ≤ ∑ j ∈ Finset.range (k - 1), N (j + 1))
(hN : ∀ j < k - 1, N (j + 1) ≤ 4 * (3 * M) ^ j * n) :
T ≤ depthConstant k M * n := by
calc
T ≤ ∑ j ∈ Finset.range (k - 1), N (j + 1) := hsteps
_ ≤ ∑ j ∈ Finset.range (k - 1), 4 * (3 * M) ^ j * n :=
Finset.sum_le_sum fun j hj => hN j (Finset.mem_range.mp hj)
_ = depthConstant k M * n := by
simp only [depthConstant, ← Finset.sum_mul, ← Finset.mul_sum]
/-- Count B-edges by their petal width. The integral multiplicative form
retains the exact bound without truncating division. -/
theorem right_steps_mul_le (M n k : ℕ) (hM : 0 < M) (b : ℕ → ℕ)
(hinsert : ∀ j < k - 1, b j * M ^ (j + 1) ≤ 4 * (3 * M) ^ j * n) :
(∑ j ∈ Finset.range (k - 1), b j) * M ≤ rightConstant k * n := by
have hwidth : ∀ j < k - 1, b j * M ≤ 4 * 3 ^ j * n := by
intro j hj
apply Nat.le_of_mul_le_mul_right (c := M ^ j) _ (pow_pos hM j)
simpa [pow_succ, mul_pow, mul_assoc, mul_comm, mul_left_comm] using hinsert j hj
calc
(∑ j ∈ Finset.range (k - 1), b j) * M =
∑ j ∈ Finset.range (k - 1), b j * M := Finset.sum_mul _ _ _
_ ≤ ∑ j ∈ Finset.range (k - 1), 4 * 3 ^ j * n :=
Finset.sum_le_sum fun j hj => hwidth j (Finset.mem_range.mp hj)
_ = rightConstant k * n := by
simp only [rightConstant, ← Finset.sum_mul, ← Finset.mul_sum]
section Trace
open RemovalCharging
variable {α : Type*} [DecidableEq α] {T : ℕ}
/-- Count actual edges by their insertion events, grouped by positive width. -/
theorem trace_steps_le_insertions (tr : Trace α T) (k : ℕ)
(hbatch : ∀ t < T, (tr.inserted t).Nonempty)
(hwidth : ∀ t < T, ∀ C ∈ tr.inserted t, C.card < k) :
T ≤ ∑ j ∈ Finset.range (k - 1), tr.insertions T (j + 1) := by
have hsplit : ∀ t < T, (∑ j ∈ Finset.range (k - 1),
widthCount (tr.inserted t) (j + 1)) = (tr.inserted t).card := by
intro t ht
calc
_ = ∑ j ∈ Finset.Ico 1 k, widthCount (tr.inserted t) j := by
rw [Finset.sum_Ico_eq_sum_range]
simp [Nat.add_comm]
_ = ((tr.inserted t).filter fun C => C.card ∈ Finset.Ico 1 k).card :=
Finset.sum_card_fiberwise_eq_card_filter _ _ _
_ = (tr.inserted t).card := by
congr 1
apply Finset.filter_eq_self.mpr
intro C hC
exact Finset.mem_Ico.mpr
⟨(tr.inserted_nonempty t ht C hC).card_pos, hwidth t ht C hC⟩
calc
T = ∑ _t ∈ Finset.range T, 1 := by simp
_ ≤ ∑ t ∈ Finset.range T, (tr.inserted t).card :=
Finset.sum_le_sum fun t ht => (hbatch t (Finset.mem_range.mp ht)).card_pos
_ = ∑ t ∈ Finset.range T, ∑ j ∈ Finset.range (k - 1),
widthCount (tr.inserted t) (j + 1) :=
Finset.sum_congr rfl fun t ht => (hsplit t (Finset.mem_range.mp ht)).symm
_ = ∑ j ∈ Finset.range (k - 1), tr.insertions T (j + 1) := by
rw [Finset.sum_comm]
rfl
/-- Nonempty strict-subset replacements never remove an inserted unit clause. -/
theorem trace_units_le (tr : Trace α T) (U : Finset α)
(hsupport : ∀ C ∈ tr.live T, C ⊆ U) : tr.insertions T 1 ≤ U.card := by
have hremoved : tr.removals T 1 = 0 := by
apply Finset.sum_eq_zero
intro t ht
apply Finset.card_eq_zero.mpr
apply Finset.eq_empty_iff_forall_notMem.mpr
intro C hC
obtain ⟨hCR, hC1⟩ := Finset.mem_filter.mp hC
obtain ⟨Q, hQI, hQC⟩ := tr.removed_has_subset (Finset.mem_range.mp ht) hCR
have hpos := (tr.inserted_nonempty t (Finset.mem_range.mp ht) Q hQI).card_pos
have hlt := Finset.card_lt_card hQC
omega
rw [tr.accounting T 1 le_rfl, hremoved, Nat.add_zero]
have hdeg : ∀ a, widthLiteralDegree (tr.live T) 1 a ≤ 1 := by
intro a
calc
_ ≤ ({({a} : Finset α)} : Finset (Finset α)).card := by
apply Finset.card_le_card
intro C hC
obtain ⟨_, hC1, ha⟩ := Finset.mem_filter.mp hC
obtain ⟨b, rfl⟩ := Finset.card_eq_one.mp hC1
have hab : a = b := Finset.mem_singleton.mp ha
simp [hab]
_ = 1 := Finset.card_singleton _
simpa using widthCount_le_universe_mul (tr.live T) U 1 1
(tr.live_nonempty T le_rfl) hsupport hdeg
/-- Equation `spar-insertions` for the actual insertion and removal events of
a finite path; the marked-degree hypothesis is supplied by priority. -/
theorem trace_insertion_recurrence (tr : Trace α T) (M n k : ℕ) (U : Finset α)
(hU : U.card ≤ 2 * n)
(hsupport : ∀ C ∈ tr.live T, C ⊆ U)
(hdegree : ∀ t ≤ T, ∀ j < k, ∀ S : Finset α, 0 < S.card → S.card < j →
((tr.live t).filter fun C => C.card = j ∧ S ⊆ C).card ≤
2 * M ^ (j - S.card)) :
∀ q < k - 1, tr.insertions T (q + 1) ≤ 4 * n * M ^ q +
2 * ∑ i ∈ Finset.range q, M ^ (q - i) * tr.insertions T (i + 1) := by
intro q hq
cases q with
| zero =>
have hu := (trace_units_le tr U hsupport).trans hU
simpa using hu.trans (show 2 * n ≤ 4 * n by omega)
| succ q =>
have hj : q + 1 + 1 < k := by omega
have hfinal : widthCount (tr.live T) (q + 1 + 1) ≤
4 * n * M ^ (q + 1) := by
have hdeg : ∀ a, widthLiteralDegree (tr.live T) (q + 1 + 1) a ≤
2 * M ^ (q + 1) := by
intro a
simpa [widthLiteralDegree] using
hdegree T le_rfl (q + 1 + 1) hj {a} (by simp) (by simp)
calc
_ ≤ (2 * M ^ (q + 1)) * U.card :=
widthCount_le_universe_mul (tr.live T) U _ _
(tr.live_nonempty T le_rfl) hsupport hdeg
_ ≤ (2 * M ^ (q + 1)) * (2 * n) := Nat.mul_le_mul_left _ hU
_ = 4 * n * M ^ (q + 1) := by ring
have hrem : tr.removals T (q + 1 + 1) ≤
2 * ∑ i ∈ Finset.range (q + 1 + 1),
M ^ (q + 1 + 1 - i) * tr.insertions T i := by
calc
_ ≤ ∑ t ∈ Finset.range T,
2 * ∑ i ∈ Finset.range (q + 1 + 1),
M ^ (q + 1 + 1 - i) * widthCount (tr.inserted t) i := by
apply Finset.sum_le_sum
intro t ht
apply removed_card_le (tr.live t) (tr.removed t) (tr.inserted t)
· exact Finset.sdiff_subset
· exact tr.inserted_nonempty t (Finset.mem_range.mp ht)
· intro C hC
exact tr.removed_has_subset (Finset.mem_range.mp ht) hC
· intro S _ hS hSj
exact hdegree t (Nat.le_of_lt (Finset.mem_range.mp ht)) _ hj S hS hSj
_ = 2 * ∑ i ∈ Finset.range (q + 1 + 1),
M ^ (q + 1 + 1 - i) * tr.insertions T i := by
rw [← Finset.mul_sum, Finset.sum_comm]
simp only [Trace.insertions, Finset.mul_sum]
rw [Finset.sum_range_succ'] at hrem
simp only [tr.insertions_zero, Nat.mul_zero, Nat.add_zero,
Nat.add_sub_add_right] at hrem
rw [tr.accounting T (q + 1 + 1) le_rfl]
exact Nat.add_le_add hfinal hrem
/-- The sharp source bound, now applied to an actual finite replacement trace. -/
theorem trace_insertions_le (tr : Trace α T) (M n k : ℕ) (U : Finset α)
(hU : U.card ≤ 2 * n)
(hsupport : ∀ C ∈ tr.live T, C ⊆ U)
(hdegree : ∀ t ≤ T, ∀ j < k, ∀ S : Finset α, 0 < S.card → S.card < j →
((tr.live t).filter fun C => C.card = j ∧ S ⊆ C).card ≤
2 * M ^ (j - S.card)) :
∀ j < k - 1, tr.insertions T (j + 1) ≤ 4 * (3 * M) ^ j * n :=
insertion_le M n k (tr.insertions T)
(trace_insertion_recurrence tr M n k U hU hsupport hdegree)
/-- The source depth bound counts every edge of the same concrete path. -/
theorem trace_depth_le (tr : Trace α T) (M n k : ℕ) (U : Finset α)
(hU : U.card ≤ 2 * n)
(hsupport : ∀ C ∈ tr.live T, C ⊆ U)
(hbatch : ∀ t < T, (tr.inserted t).Nonempty)
(hwidth : ∀ t < T, ∀ C ∈ tr.inserted t, C.card < k)
(hdegree : ∀ t ≤ T, ∀ j < k, ∀ S : Finset α, 0 < S.card → S.card < j →
((tr.live t).filter fun C => C.card = j ∧ S ⊆ C).card ≤
2 * M ^ (j - S.card)) :
T ≤ depthConstant k M * n :=
depth_le M n k T (tr.insertions T) (trace_steps_le_insertions tr k hbatch hwidth)
(trace_insertions_le tr M n k U hU hsupport hdegree)
/-- A B-edge of petal width `w` consumes at least `M^w` actual insertion events. -/
theorem trace_right_steps_mul_le (tr : Trace α T) (M n k : ℕ) (hM : 0 < M)
(U : Finset α) (hU : U.card ≤ 2 * n)
(hsupport : ∀ C ∈ tr.live T, C ⊆ U)
(hdegree : ∀ t ≤ T, ∀ j < k, ∀ S : Finset α, 0 < S.card → S.card < j →
((tr.live t).filter fun C => C.card = j ∧ S ⊆ C).card ≤
2 * M ^ (j - S.card))
(b : ℕ → Bool) (w : ℕ → ℕ)
(hwidth : ∀ t < T, b t = true → 0 < w t ∧ w t < k)
(hbatch : ∀ t < T, b t = true → M ^ w t ≤ widthCount (tr.inserted t) (w t)) :
((Finset.range T).filter fun t => b t = true).card * M ≤ rightConstant k * n := by
let R := (Finset.range T).filter fun t => b t = true
let counts := fun j => (R.filter fun t => w t = j + 1).card
have hsplit : R.card = ∑ j ∈ Finset.range (k - 1), counts j := by
symm
calc
_ = ∑ j ∈ Finset.Ico 1 k, (R.filter fun t => w t = j).card := by
rw [Finset.sum_Ico_eq_sum_range]
simp [counts, Nat.add_comm]
_ = (R.filter fun t => w t ∈ Finset.Ico 1 k).card :=
Finset.sum_card_fiberwise_eq_card_filter _ _ _
_ = R.card := by
congr 1
apply Finset.filter_eq_self.mpr
intro t ht
obtain ⟨ht, hb⟩ := Finset.mem_filter.mp ht
exact Finset.mem_Ico.mpr (hwidth t (Finset.mem_range.mp ht) hb)
change R.card * M ≤ rightConstant k * n
rw [hsplit]
apply right_steps_mul_le M n k hM counts
intro j hj
apply le_trans _ (trace_insertions_le tr M n k U hU hsupport hdegree j hj)
calc
counts j * M ^ (j + 1) = ∑ t ∈ R.filter (fun t => w t = j + 1),
M ^ (j + 1) := by simp [counts]
_ ≤ ∑ t ∈ R.filter (fun t => w t = j + 1),
widthCount (tr.inserted t) (j + 1) := by
apply Finset.sum_le_sum
intro t ht
obtain ⟨htR, hw⟩ := Finset.mem_filter.mp ht
obtain ⟨ht, hb⟩ := Finset.mem_filter.mp htR
simpa only [hw] using hbatch t (Finset.mem_range.mp ht) hb
_ ≤ ∑ t ∈ Finset.range T, widthCount (tr.inserted t) (j + 1) :=
Finset.sum_le_sum_of_subset ((Finset.filter_subset _ _).trans (Finset.filter_subset _ _))
end Trace
section SelectedTrace
open RemovalCharging DisjointBranch
variable {n T : ℕ}
theorem path_invariants (F : ℕ → SAT.CNF (Fin n)) (c : ℕ → ℕ)
(H : ℕ → SAT.Clause (Fin n)) (b : ℕ → Bool) (M k : ℕ)
(hselect : ∀ t < T, SparsePriority.Priority (F t) M (c t) (H t))
(hnext : ∀ t < T, F (t + 1) =
if b t then childB (F t) (c t) (H t) else childA (F t) (c t) (H t))
(hanti : SunflowerBranch.Antichain (F 0))
(hnt : ∀ C ∈ F 0, ¬ C.IsTautology) (hwidth : SAT.WidthAtMost k (F 0)) :
∀ t ≤ T, SunflowerBranch.Antichain (F t) ∧
(∀ C ∈ F t, ¬ C.IsTautology) ∧ SAT.WidthAtMost k (F t) := by
intro t ht
induction t with
| zero => exact ⟨hanti, hnt, hwidth⟩
| succ t ih =>
have htT : t < T := by omega
obtain ⟨_, hn, hw⟩ := ih (by omega)
have hs := (hselect t htT).spec
have hsel : (selected (F t) (c t) (H t)).Nonempty := by
obtain ⟨C, hCF, hCc, hHC⟩ := hs.1
exact ⟨C, mem_selected.mpr ⟨hCF, hCc, hHC⟩⟩
rw [hnext t htT]
cases hb : b t
· simp only [Bool.false_eq_true, ↓reduceIte]
exact ⟨childA_antichain _ _ _, childA_not_tautological hn hsel,
childA_widthAtMost hw hsel hs.2.2.1⟩
· simp only [↓reduceIte]
exact ⟨childB_antichain _ _ _, childB_not_tautological hn,
childB_widthAtMost hw hsel (Finset.card_pos.mp hs.2.1) hs.2.2.1⟩
/-- The concrete replacement trace induced by a selected formula path. -/
def selectedTrace (F : ℕ → SAT.CNF (Fin n)) (c : ℕ → ℕ)
(H : ℕ → SAT.Clause (Fin n)) (b : ℕ → Bool) (M k : ℕ)
(hselect : ∀ t < T, SparsePriority.Priority (F t) M (c t) (H t))
(hnext : ∀ t < T, F (t + 1) =
if b t then childB (F t) (c t) (H t) else childA (F t) (c t) (H t))
(hanti : SunflowerBranch.Antichain (F 0))
(hnt : ∀ C ∈ F 0, ¬ C.IsTautology) (hwidth : SAT.WidthAtMost k (F 0)) :
Trace (SAT.Literal (Fin n)) T where
formula := F
inserted := fun t => if b t then insertedB (F t) (c t) (H t) else {H t}
next_subset := by
intro t ht
rw [hnext t ht]
cases hb : b t <;> simp only [Bool.false_eq_true, ↓reduceIte]
· exact childA_subset _ _ _
· exact childB_subset _ _ _
inserted_live := by
intro t ht
have hinv := path_invariants F c H b M k hselect hnext hanti hnt hwidth t (by omega)
have hs := (hselect t ht).spec
have hsel : (selected (F t) (c t) (H t)).Nonempty := by
obtain ⟨C, hCF, hCc, hHC⟩ := hs.1
exact ⟨C, mem_selected.mpr ⟨hCF, hCc, hHC⟩⟩
rw [hnext t ht]
cases hb : b t <;> simp only [Bool.false_eq_true, ↓reduceIte]
· exact Finset.singleton_subset_iff.mpr (core_mem_childA hinv.1 hsel hs.2.2.1)
· exact insertedB_subset_childB hinv.1 hsel (Finset.card_pos.mp hs.2.1)
hs.2.2.1 hinv.2.1
fresh := by
intro t ht
have hinv := path_invariants F c H b M k hselect hnext hanti hnt hwidth t (by omega)
have hs := (hselect t ht).spec
cases hb : b t <;> simp only [Bool.false_eq_true, ↓reduceIte]
· apply Finset.disjoint_singleton_right.mpr
apply core_new hinv.1 _ hs.2.2.1
obtain ⟨C, hCF, hCc, hHC⟩ := hs.1
exact ⟨C, mem_selected.mpr ⟨hCF, hCc, hHC⟩⟩
· exact insertedB_disjoint _ _ _
inserted_nonempty := by
intro t ht Q hQ
have hs := (hselect t ht).spec
cases hb : b t <;> simp only [hb, Bool.false_eq_true, ↓reduceIte] at hQ
· have hQH := Finset.mem_singleton.mp hQ
rw [hQH]
exact Finset.card_pos.mp hs.2.1
· exact insertedB_nonempty hs.2.2.1 hQ
removed_subset := by
intro t ht C hC hgone
have hinv := path_invariants F c H b M k hselect hnext hanti hnt hwidth t (by omega)
have hs := (hselect t ht).spec
rw [hnext t ht] at hgone
cases hb : b t <;> simp only [hb, Bool.false_eq_true, ↓reduceIte] at hgone ⊢
· exact ⟨H t, Finset.mem_singleton_self _,
removed_childA_contains_core hinv.1 hs.2.2.1 hC hgone⟩
· exact removed_childB_contains_inserted hinv.1 (Finset.card_pos.mp hs.2.1) hC hgone
/-- Priority bounds marked subset degrees at every prefix of a selected path. -/
theorem trace_marked_degree (tr : Trace (SAT.Literal (Fin n)) T) (M : ℕ)
(hM : 2 ≤ M)
(hstep : ∀ t < T, ∃ c H,
SparsePriority.Priority (tr.formula t) M c H ∧
(tr.inserted t = {H} ∨ tr.inserted t = insertedB (tr.formula t) c H)) :
∀ t ≤ T, ∀ (j : ℕ) (S : SAT.Clause (Fin n)), 0 < S.card → S.card < j →
SparsePriority.degree (tr.live t) j S < 2 * M ^ (j - S.card) := by
intro t ht
induction t with
| zero =>
intro j S _ _
change (selected ∅ j S).card < 2 * M ^ (j - S.card)
simp only [selected, Finset.filter_empty, Finset.card_empty]
exact Nat.mul_pos (by omega) (pow_pos (by omega) _)
| succ t ih =>
intro j S hS hSj
have htT : t < T := by omega
obtain ⟨c, H, hsel, hA | hB⟩ := hstep t htT
· apply SparsePriority.Priority.marked_degree_childA hM hsel
(tr.live_subset_formula t (by omega))
· intro C hC
rcases Finset.mem_union.mp hC with hC | hC
· exact Finset.mem_union.mpr (Or.inl (Finset.mem_inter.mp hC).1)
· exact Finset.mem_union.mpr (Or.inr (hA ▸ hC))
· exact hS
· exact hSj
· exact ih (by omega) j S hS hSj
· apply SparsePriority.Priority.marked_degree_childB hM hsel
(tr.live_subset_formula t (by omega))
· intro C hC
rcases Finset.mem_union.mp hC with hC | hC
· exact Finset.mem_union.mpr
(Or.inl (Finset.mem_union.mpr (Or.inl (Finset.mem_inter.mp hC).1)))
· rw [hB] at hC
rcases Finset.mem_union.mp (Finset.mem_sdiff.mp hC).1 with hP | hU
· exact Finset.mem_union.mpr (Or.inl (Finset.mem_union.mpr (Or.inr hP)))
· exact Finset.mem_union.mpr (Or.inr hU)
· exact hS
· exact hSj
· exact ih (by omega) j S hS hSj
/-- Every actual selected path has the draft's linear depth bound. -/
theorem selected_path_depth_le (F : ℕ → SAT.CNF (Fin n)) (c : ℕ → ℕ)
(H : ℕ → SAT.Clause (Fin n)) (b : ℕ → Bool) (M k : ℕ) (hM : 2 ≤ M)
(hselect : ∀ t < T, SparsePriority.Priority (F t) M (c t) (H t))
(hnext : ∀ t < T, F (t + 1) =
if b t then childB (F t) (c t) (H t) else childA (F t) (c t) (H t))
(hanti : SunflowerBranch.Antichain (F 0))
(hnt : ∀ C ∈ F 0, ¬ C.IsTautology) (hwidth : SAT.WidthAtMost k (F 0)) :
T ≤ depthConstant k M * n := by
let tr := selectedTrace F c H b M k hselect hnext hanti hnt hwidth
have hstep : ∀ t < T, ∃ c H,
SparsePriority.Priority (tr.formula t) M c H ∧
(tr.inserted t = {H} ∨ tr.inserted t = insertedB (tr.formula t) c H) := by
intro t ht
refine ⟨c t, H t, hselect t ht, ?_⟩
cases hb : b t <;> simp [tr, selectedTrace, hb]
apply trace_depth_le tr M n k (literalUniverse (V := Fin n))
· simpa using (literalUniverse_card_le (V := Fin n))
· intro C _ a _
exact mem_literalUniverse a
· intro t ht
have hs := (hselect t ht).spec
have hinv := path_invariants F c H b M k hselect hnext hanti hnt hwidth t (by omega)
change (if b t then insertedB (F t) (c t) (H t) else {H t}).Nonempty
cases hb : b t
· simp
· simp only [↓reduceIte]
obtain ⟨C, hCF, hCc, hHC⟩ := hs.1
refine ⟨C \ H t, petals_subset_insertedB hinv.1 (Finset.card_pos.mp hs.2.1) ?_⟩
exact Finset.mem_image.mpr ⟨C, mem_selected.mpr ⟨hCF, hCc, hHC⟩, rfl⟩
· intro t ht Q hQ
have hs := (hselect t ht).spec
have hinv := path_invariants F c H b M k hselect hnext hanti hnt hwidth t (by omega)
obtain ⟨C, hCF, hCc, _⟩ := hs.1
have hck : c t ≤ k := hCc ▸ hinv.2.2 C hCF
change Q ∈ (if b t then insertedB (F t) (c t) (H t) else {H t}) at hQ
cases hb : b t <;> simp only [hb, Bool.false_eq_true, ↓reduceIte] at hQ
· rw [Finset.mem_singleton.mp hQ]
exact hs.2.2.1.trans_le hck
· exact (insertedB_width_lt (Finset.card_pos.mp hs.2.1) hs.2.2.1 hQ).trans_le hck
· intro t ht j _ S hS hSj
simpa [SparsePriority.degree, selected] using
(trace_marked_degree tr M hM hstep t ht j S hS hSj).le
/-- The B-choice bound for the same actual selected path. -/
theorem selected_path_right_steps_mul_le (F : ℕ → SAT.CNF (Fin n)) (c : ℕ → ℕ)
(H : ℕ → SAT.Clause (Fin n)) (b : ℕ → Bool) (M k : ℕ) (hM : 2 ≤ M)
(hselect : ∀ t < T, SparsePriority.Priority (F t) M (c t) (H t))
(hnext : ∀ t < T, F (t + 1) =
if b t then childB (F t) (c t) (H t) else childA (F t) (c t) (H t))
(hanti : SunflowerBranch.Antichain (F 0))
(hnt : ∀ C ∈ F 0, ¬ C.IsTautology) (hwidth : SAT.WidthAtMost k (F 0)) :
((Finset.range T).filter fun t => b t = true).card * M ≤ rightConstant k * n := by
let tr := selectedTrace F c H b M k hselect hnext hanti hnt hwidth
have hstep : ∀ t < T, ∃ c H,
SparsePriority.Priority (tr.formula t) M c H ∧
(tr.inserted t = {H} ∨ tr.inserted t = insertedB (tr.formula t) c H) := by
intro t ht
refine ⟨c t, H t, hselect t ht, ?_⟩
cases hb : b t <;> simp [tr, selectedTrace, hb]
refine trace_right_steps_mul_le tr M n k (by omega) (literalUniverse (V := Fin n))
?_ ?_ ?_ b (fun t => c t - (H t).card) ?_ ?_
· simpa using (literalUniverse_card_le (V := Fin n))
· intro C _ a _
exact mem_literalUniverse a
· intro t ht j _ S hS hSj
simpa [SparsePriority.degree, selected] using
(trace_marked_degree tr M hM hstep t ht j S hS hSj).le
· intro t ht _
have hs := (hselect t ht).spec
have hinv := path_invariants F c H b M k hselect hnext hanti hnt hwidth t (by omega)
obtain ⟨C, hCF, hCc, _⟩ := hs.1
have hck : c t ≤ k := hCc ▸ hinv.2.2 C hCF
exact ⟨Nat.sub_pos_of_lt hs.2.2.1,
(Nat.sub_lt (hs.2.1.trans hs.2.2.1) hs.2.1).trans_le hck⟩
· intro t ht hb
have hs := (hselect t ht).spec
have hinv := path_invariants F c H b M k hselect hnext hanti hnt hwidth t (by omega)
have h := hs.2.2.2.trans
(selected_card_le_insertedB_width hinv.1 (Finset.card_pos.mp hs.2.1))
simpa only [tr, selectedTrace, hb, ↓reduceIte, widthCount] using h
inductive SelectedPath (M : ℕ) : SAT.CNF (Fin n) → List Bool → SAT.CNF (Fin n) → Prop
| nil (F : SAT.CNF (Fin n)) : SelectedPath M F [] F
| step {F G : SAT.CNF (Fin n)} {p : List Bool} {c : ℕ} {H : SAT.Clause (Fin n)}
(b : Bool) (hselect : SparsePriority.Priority F M c H)
(tail : SelectedPath M (if b then childB F c H else childA F c H) p G) :
SelectedPath M F (b :: p) G
theorem SelectedPath.trace_data {M : ℕ} {F G : SAT.CNF (Fin n)} {p : List Bool}
(hp : SelectedPath M F p G) :
∃ (formulas : ℕ → SAT.CNF (Fin n)) (widths : ℕ → ℕ)
(cores : ℕ → SAT.Clause (Fin n)), formulas 0 = F ∧
(∀ t < p.length, SparsePriority.Priority (formulas t) M (widths t) (cores t)) ∧
(∀ t < p.length, formulas (t + 1) = if p.getD t false then
childB (formulas t) (widths t) (cores t) else
childA (formulas t) (widths t) (cores t)) := by
induction hp with
| nil F =>
exact ⟨fun _ => F, fun _ => 0, fun _ => ∅, rfl, by simp, by simp⟩
| @step F G p c H b hs hp ih =>
obtain ⟨f, w, s, hf, hselect, hnext⟩ := ih
refine ⟨(fun | 0 => F | t + 1 => f t), (fun | 0 => c | t + 1 => w t),
(fun | 0 => H | t + 1 => s t), rfl, ?_, ?_⟩
· intro t ht
cases t with
| zero => exact hs
| succ t => exact hselect t (by simpa using ht)
· intro t ht
cases t with
| zero => simpa using hf
| succ t => simpa using hnext t (by simpa using ht)
theorem SelectedPath.length_le {M k : ℕ} {F G : SAT.CNF (Fin n)} {p : List Bool}
(hp : SelectedPath M F p G) (hM : 2 ≤ M)
(hanti : SunflowerBranch.Antichain F)
(hnt : ∀ C ∈ F, ¬ C.IsTautology) (hwidth : SAT.WidthAtMost k F) :
p.length ≤ depthConstant k M * n := by
obtain ⟨f, w, s, hf, hs, hn⟩ := hp.trace_data
apply selected_path_depth_le f w s (fun t => p.getD t false) M k hM hs hn
· simpa only [hf] using hanti
· simpa only [hf] using hnt
· simpa only [hf] using hwidth
theorem SelectedPath.count_true_mul_le {M k : ℕ} {F G : SAT.CNF (Fin n)} {p : List Bool}
(hp : SelectedPath M F p G) (hM : 2 ≤ M)
(hanti : SunflowerBranch.Antichain F)
(hnt : ∀ C ∈ F, ¬ C.IsTautology) (hwidth : SAT.WidthAtMost k F) :
p.count true * M ≤ rightConstant k * n := by
have hpositions : ((Finset.range p.length).filter fun t => p.getD t false = true) =
BranchTree.bPositions p := by
ext t
simp [BranchTree.bPositions, Option.getD_eq_iff]
obtain ⟨f, w, s, hf, hs, hn⟩ := hp.trace_data
rw [← BranchTree.card_bPositions_eq_count, ← hpositions]
apply selected_path_right_steps_mul_le f w s (fun t => p.getD t false) M k hM hs hn
· simpa only [hf] using hanti
· simpa only [hf] using hnt
· simpa only [hf] using hwidth
end SelectedTrace
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseCharging