File size: 3,391 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Streams.MeasuredInitialization
import OAI.Combinatorics.LowSpaceSubsetSum.Storage.MeasuredReaderCells
namespace OAI
/-! # Live cells during direct tournament initialization
The left subtree remains live while the right subtree is constructed. A
parent shares the completed children; it does not copy their payloads.
-/
namespace LowSpaceSubsetSum.MeasuredBuildCells
variable {α : Type*}
def run (N : ℕ) (key : α → (ℤ × ℕ) × ℕ) : (d : ℕ) →
((Fin d → Bool) → (Option α × ℕ) × ℕ) → (Tournament.Tree α d × ℕ) × ℕ
| 0, front =>
let x := front Fin.elim0
((.leaf x.1.1, x.1.2 + 1), x.2 + 2 * N + 8)
| d + 1, front =>
let l := run N key d (fun p => front (Fin.cons false p))
let r := run N key d (fun p => front (Fin.cons true p))
let w := MeasuredReaderCells.pick key (Tournament.winner l.1.1) (Tournament.winner r.1.1)
let leftCells := N * (Tournament.nodes l.1.1 + 1)
let bothCells := leftCells + N * (Tournament.nodes r.1.1 + 1)
((.node w.1.1 l.1.1 r.1.1, l.1.2 + r.1.2 + w.1.2 + 5),
max (l.2 + 8) (max (leftCells + r.2 + 16) (bothCells + w.2 + N + 24)))
theorem run_value (N : ℕ) (key : α → (ℤ × ℕ) × ℕ) (d : ℕ)
(front : (Fin d → Bool) → (Option α × ℕ) × ℕ) :
(run N key d front).1 = Tournament.measuredBuild (fun x => (key x).1) d
(fun p => (front p).1) := by
induction d with
| zero => rfl
| succ d ih => simp only [run, Tournament.measuredBuild, MeasuredReaderCells.pick_value, ih]
private theorem step_bound (N K R d l r w : ℕ)
(hl : l ≤ (d + 1) * (4 * (N * 2 ^ (d + 1)) + K + R + 64))
(hr : r ≤ (d + 1) * (4 * (N * 2 ^ (d + 1)) + K + R + 64))
(hw : w ≤ K + 8) :
max (l + 8) (max (N * 2 ^ (d + 1) + r + 16)
(N * 2 ^ (d + 1) + N * 2 ^ (d + 1) + w + N + 24)) ≤
(d + 2) * (4 * (N * 2 ^ (d + 2)) + K + R + 64) := by
have hpow : 1 ≤ 2 ^ (d + 1) := Nat.one_le_two_pow
have hN : N ≤ N * 2 ^ (d + 1) := by nlinarith only [hpow]
have hmul : N * 2 ^ (d + 2) = 2 * (N * 2 ^ (d + 1)) := by
rw [show d + 2 = (d + 1) + 1 by omega, pow_succ]
ring
have hcoeff : 4 * (N * 2 ^ (d + 1)) + K + R + 64 ≤
4 * (N * 2 ^ (d + 2)) + K + R + 64 := by omega
have hl' := hl.trans (Nat.mul_le_mul_left (d + 1) hcoeff)
have hr' := hr.trans (Nat.mul_le_mul_left (d + 1) hcoeff)
simp only [Nat.add_mul, Nat.one_mul] at hl' hr' ⊢
omega
theorem run_cells (N : ℕ) (key : α → (ℤ × ℕ) × ℕ) (K R : ℕ)
(hk : ∀ x, (key x).2 ≤ K) (d : ℕ)
(front : (Fin d → Bool) → (Option α × ℕ) × ℕ) (hf : ∀ p, (front p).2 ≤ R) :
(run N key d front).2 ≤ (d + 1) * (4 * (N * 2 ^ (d + 1)) + K + R + 64) := by
induction d with
| zero =>
have h := hf Fin.elim0
simp only [run, Nat.zero_add, pow_one, Nat.one_mul]
omega
| succ d ih =>
have hl := ih (fun p => front (Fin.cons false p)) (fun p => hf _)
have hr := ih (fun p => front (Fin.cons true p)) (fun p => hf _)
have hw := MeasuredReaderCells.pick_cells key K hk
(Tournament.winner (run N key d (fun p => front (Fin.cons false p))).1.1)
(Tournament.winner (run N key d (fun p => front (Fin.cons true p))).1.1)
simp only [run, Tournament.nodes_exact]
exact step_bound N K R d _ _ _ hl hr hw
end LowSpaceSubsetSum.MeasuredBuildCells
end OAI
|