math / data /lean /OAI /Algorithms /SubexponentialSAT /SqrtLogSpace /DisjointReuse /SparseCharging.lean
Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseCharging.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 28.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseCharging.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseCharging.lean
-
curl -L -o SparseCharging.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseCharging.lean
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⟩ | |
| | 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 | |