File size: 5,532 Bytes
5d5048e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorCells
import OAI.Combinatorics.LowSpaceSubsetSum.Storage.StoredTerminalCells
import OAI.Combinatorics.LowSpaceSubsetSum.Storage.StoredQueryCells
import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorArrays
namespace OAI
/-! # Full interrupted-checker buffer lifetime
The header, the interval traversal and the terminal run in the same order
as the budgeted checker. The added peak field accounts for live temporary
lists and continuation cells; shared entry payloads and tables are external.
-/
namespace LowSpaceSubsetSum.BudgetedCheckerCells
open BudgetedSeparatorCells StoredSeparatorCheck
variable {n g : ℕ}
def run (scratch capacity : ℕ) (target : ℤ) :
List (Block n g) → List (StoredEntry n) → List (StoredEntry n) →
ℕ → ℕ → ℕ → Execution Bool
| [], xs, ys, nx, ny, budget =>
scope 8 (BudgetedSeparatorCheck.header capacity nx ny budget) fun fits left =>
if fits then StoredTerminalCells.budgeted target xs ys nx ny left
else (BudgetedSeparatorFlow.pure false left, 0)
| b :: rest, xs, ys, nx, ny, budget =>
scope 8 (BudgetedSeparatorCheck.header capacity nx ny budget) fun fits left =>
if fits then
BudgetedSeparatorCells.run scratch b.queryBound b.leftQuery b.rightQuery
(fun _ as bs na nb remaining => run scratch capacity target rest as bs na nb remaining)
b.depth 0 b.familySize xs ys nx ny left
else (BudgetedSeparatorFlow.pure false left, 0)
theorem run_value (scratch capacity : ℕ) (target : ℤ) (blocks : List (Block n g))
(xs ys : List (StoredEntry n)) (nx ny budget : ℕ) :
(run scratch capacity target blocks xs ys nx ny budget).1 =
BudgetedSeparatorCheck.execute capacity target blocks xs ys nx ny budget := by
induction blocks generalizing xs ys nx ny budget with
| nil =>
simp only [run, scope_value, BudgetedSeparatorCheck.execute]
congr 1
funext fits left
split
· exact StoredTerminalCells.budgeted_value _ _ _ _ _ _
· rfl
| cons b rest ih =>
simp only [run, scope_value, BudgetedSeparatorCheck.execute]
congr 1
funext fits left
split
· simp only [BudgetedSeparatorCells.run_value, ih]
· rfl
def bound (scratch n C : ℕ) : List (Block n g) → ℕ
| [] => 8 + 72 * (n + 1) * (C + 1)
| b :: rest => 8 + (b.depth + 1) * (8 * (C + 1) + scratch) + bound scratch n C rest
theorem run_cells (scratch capacity : ℕ) (target : ℤ) (blocks : List (Block n g))
(xs ys : List (StoredEntry n)) (nx ny budget C : ℕ)
(hx : xs.length = nx) (hy : ys.length = ny) (hsize : nx + ny ≤ C) :
(run scratch capacity target blocks xs ys nx ny budget).2 ≤ bound scratch n C blocks := by
induction blocks generalizing xs ys nx ny budget with
| nil =>
rw [run, bound]
apply scope_cells
intro fits left _
split
· exact StoredTerminalCells.budgeted_cells target xs ys nx ny left C hx hy hsize
· exact Nat.zero_le _
| cons b rest ih =>
rw [run, bound]
refine le_trans (scope_cells 8 (BudgetedSeparatorCheck.header capacity nx ny budget) _
((b.depth + 1) * (8 * (C + 1) + scratch) + bound scratch n C rest) ?_) ?_
· intro fits left _
split
· apply BudgetedSeparatorCells.run_cells
· intro j as bs na nb remaining ha hb hc
exact ih as bs na nb remaining ha hb (by omega)
· exact hx
· exact hy
· exact hsize
· exact Nat.zero_le _
· omega
def arrays (scratch capacity : ℕ) (target : ℤ) (blocks : List (Block n g))
(left right : Array (StoredEntry n)) (budget : ℕ) : Execution Bool :=
scope (4 * (left.size + right.size + 1)) (BudgetedSeparatorArrays.convert left right budget)
fun lists remaining => run scratch capacity target blocks lists.1 lists.2
left.size right.size remaining
theorem arrays_value (scratch capacity : ℕ) (target : ℤ) (blocks : List (Block n g))
(left right : Array (StoredEntry n)) (budget : ℕ) :
(arrays scratch capacity target blocks left right budget).1 =
BudgetedSeparatorArrays.execute capacity target blocks left right budget := by
simp only [arrays, scope_value, run_value, BudgetedSeparatorArrays.execute]
theorem arrays_cells (scratch capacity : ℕ) (target : ℤ) (blocks : List (Block n g))
(left right : Array (StoredEntry n)) (budget C : ℕ) (hsize : left.size + right.size ≤ C) :
(arrays scratch capacity target blocks left right budget).2 ≤
4 * (C + 1) + bound scratch n C blocks := by
apply le_trans (scope_cells _ _ _ (bound scratch n C blocks) ?_)
· omega
· intro lists remaining h
obtain ⟨rfl, _, _⟩ := BudgetedSeparatorCall.value _ _ _ _ _ h
exact run_cells scratch capacity target blocks left.toList right.toList
left.size right.size remaining C (by simp) (by simp) hsize
theorem bound_le (scratch C depth : ℕ) (blocks : List (Block n g))
(hd : ∀ b ∈ blocks, b.depth ≤ depth) :
bound scratch n C blocks ≤ 8 + 72 * (n + 1) * (C + 1) +
blocks.length * (8 + (depth + 1) * (8 * (C + 1) + scratch)) := by
induction blocks with
| nil => simp [bound]
| cons b rest ih =>
have hb := hd b (by simp)
have hr := ih (fun d hd' => hd d (by simp [hd']))
have hm := Nat.mul_le_mul_right (8 * (C + 1) + scratch) (Nat.add_le_add_right hb 1)
simp only [bound, List.length_cons]
nlinarith only [hr, hm]
end LowSpaceSubsetSum.BudgetedCheckerCells
end OAI
|