| 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 |
|
|
