| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedFill |
|
|
| namespace OAI |
|
|
| /-! # Prepaid construction of a tie buffer |
|
|
| The budget guard precedes the reader, key evaluator and record copy. It can |
| therefore interrupt a long tie before materializing the entire requested |
| buffer. The reference fill appears only in correctness and completion proofs. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.BudgetedFill |
|
|
| universe u v |
| variable {α : Type u} {σ : Type v} |
|
|
| def execute (charge : ℕ) (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (cells : α → ℕ) (K : ℤ) : |
| ℕ → σ → Array α → ℕ → ℕ → Option (TieBuffer.Result α σ × ℕ) × ℕ |
| | fuel, s, buf, q, budget => |
| if charge ≤ budget then |
| let left := budget - charge |
| match fuel with |
| | 0 => (some (⟨buf, s, q⟩, left), 1) |
| | fuel + 1 => |
| let fetched := read s |
| match fetched.1 with |
| | none => (some (⟨buf, s, q + 1⟩, left), fetched.2 + 5) |
| | some (x, s') => |
| let found := key x |
| if found.1 = K then |
| let rest := execute charge read key cells K fuel s' (buf.push x) (q + 1) left |
| (rest.1, fetched.2 + found.2 + cells x + 8 + rest.2) |
| else (some (⟨buf, s, q + 1⟩, left), fetched.2 + found.2 + 6) |
| else (none, 1) |
|
|
| theorem insufficient (charge : ℕ) (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (cells : α → ℕ) (K : ℤ) |
| (fuel : ℕ) (s : σ) (buf : Array α) (q budget : ℕ) (h : budget < charge) : |
| execute charge read key cells K fuel s buf q budget = (none, 1) := by |
| rw [execute, ite_eq_right (by omega)] |
|
|
| theorem execute_value (charge : ℕ) (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (cells : α → ℕ) (K : ℤ) |
| (fuel : ℕ) (s : σ) (buf : Array α) (q budget : ℕ) |
| (out : TieBuffer.Result α σ) (left : ℕ) |
| (h : (execute charge read key cells K fuel s buf q budget).1 = some (out, left)) : |
| out = (CountedFill.fillAcc read key cells K fuel s buf q).1 ∧ left ≤ budget := by |
| induction fuel generalizing s buf q budget out left with |
| | zero => |
| rw [execute] at h |
| split at h |
| · cases h |
| exact ⟨rfl, Nat.sub_le _ _⟩ |
| · contradiction |
| | succ fuel ih => |
| rw [execute] at h |
| split at h |
| next hb => |
| dsimp only at h |
| cases hv : (read s).1 with |
| | none => |
| simp only [hv] at h |
| cases h |
| exact ⟨by simp only [CountedFill.fillAcc, hv], Nat.sub_le _ _⟩ |
| | some p => |
| rcases p with ⟨x, s'⟩ |
| simp only [hv] at h |
| split at h |
| next hk => |
| obtain ⟨he, hl⟩ := ih s' (buf.push x) (q + 1) _ out left h |
| exact ⟨by simpa only [CountedFill.fillAcc, hv, hk, ↓reduceIte] using he, |
| hl.trans (Nat.sub_le _ _)⟩ |
| next hk => |
| cases h |
| exact ⟨by simp only [CountedFill.fillAcc, hv, hk, ↓reduceIte], Nat.sub_le _ _⟩ |
| next hb => contradiction |
|
|
| private theorem queries_mono (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (cells : α → ℕ) (K : ℤ) |
| (fuel : ℕ) (s : σ) (buf : Array α) (q : ℕ) : |
| q ≤ (CountedFill.fillAcc read key cells K fuel s buf q).1.queries := by |
| induction fuel generalizing s buf q with |
| | zero => exact le_rfl |
| | succ fuel ih => |
| rw [CountedFill.fillAcc] |
| cases hv : (read s).1 with |
| | none => simp only; omega |
| | some p => |
| rcases p with ⟨x, s'⟩ |
| dsimp only |
| split |
| · exact (Nat.le_succ q).trans (ih _ _ _) |
| · simp only; omega |
| |
| theorem execute_complete (charge : ℕ) (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (cells : α → ℕ) (K : ℤ) |
| (fuel : ℕ) (s : σ) (buf : Array α) (q budget : ℕ) |
| (hbudget : charge * ((CountedFill.fillAcc read key cells K fuel s buf q).1.queries - q + 1) |
| ≤ budget) : |
| ∃ left, (execute charge read key cells K fuel s buf q budget).1 = |
| some ((CountedFill.fillAcc read key cells K fuel s buf q).1, left) := by |
| induction fuel generalizing s buf q budget with |
| | zero => |
| change charge * (q - q + 1) ≤ budget at hbudget |
| simp only [Nat.sub_self, Nat.zero_add, Nat.mul_one] at hbudget |
| exact ⟨budget - charge, by rw [execute, ite_eq_left hbudget]; rfl⟩ |
| | succ fuel ih => |
| have hc : charge ≤ budget := by |
| have hm := Nat.mul_le_mul_left charge |
| (show 1 ≤ (CountedFill.fillAcc read key cells K (fuel + 1) s buf q).1.queries - q + 1 |
| by omega) |
| simpa only [Nat.mul_one] using hm.trans hbudget |
| rw [execute, ite_eq_left hc] |
| dsimp only |
| cases hv : (read s).1 with |
| | none => exact ⟨budget - charge, by simp only [CountedFill.fillAcc, hv]⟩ |
| | some p => |
| rcases p with ⟨x, s'⟩ |
| dsimp only |
| by_cases hk : (key x).1 = K |
| · simp only [hk, ↓reduceIte] |
| have hm := queries_mono read key cells K fuel s' (buf.push x) (q + 1) |
| have hb : charge * |
| ((CountedFill.fillAcc read key cells K fuel s' (buf.push x) (q + 1)).1.queries - |
| (q + 1) + 1) ≤ budget - charge := by |
| simp only [CountedFill.fillAcc, hv, hk, ↓reduceIte] at hbudget |
| have he : |
| (CountedFill.fillAcc read key cells K fuel s' (buf.push x) (q + 1)).1.queries - q = |
| (CountedFill.fillAcc read key cells K fuel s' (buf.push x) (q + 1)).1.queries - |
| (q + 1) + 1 := by omega |
| rw [he, Nat.mul_add, Nat.mul_one] at hbudget |
| omega |
| simpa only [CountedFill.fillAcc, hv, hk, ↓reduceIte] using |
| ih s' (buf.push x) (q + 1) (budget - charge) hb |
| · exact ⟨budget - charge, by simp only [hk, ↓reduceIte, CountedFill.fillAcc, hv]⟩ |
| |
| theorem execute_work (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (cells : α → ℕ) (K : ℤ) (R L S charge : ℕ) |
| (hr : ∀ s, (read s).2 ≤ R) (hk : ∀ x, (key x).2 ≤ L) |
| (hs : ∀ x, cells x ≤ S) (hcharge : R + L + S + 8 ≤ charge) |
| (fuel : ℕ) (s : σ) (buf : Array α) (q budget : ℕ) : |
| (execute charge read key cells K fuel s buf q budget).2 ≤ budget + 1 := by |
| induction fuel generalizing s buf q budget with |
| | zero => simp only [execute]; split <;> dsimp only <;> omega |
| | succ fuel ih => |
| have hread := hr s |
| rw [execute] |
| split |
| next hb => |
| dsimp only |
| cases hv : (read s).1 with |
| | none => ((try dsimp only); omega) |
| | some p => |
| rcases p with ⟨x, s'⟩ |
| have hkey := hk x |
| have hcell := hs x |
| dsimp only |
| split |
| · have hi := ih s' (buf.push x) (q + 1) (budget - charge) |
| try dsimp only |
| omega |
| · ((try dsimp only); omega) |
| next hb => ((try dsimp only); omega) |
| |
| /-- A successful fill charges its work against the budget it actually spent, |
| so the remaining allowance can be passed to the next join stage. -/ |
| theorem execute_spent (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (cells : α → ℕ) (K : ℤ) (R L S charge : ℕ) |
| (hr : ∀ s, (read s).2 ≤ R) (hk : ∀ x, (key x).2 ≤ L) |
| (hs : ∀ x, cells x ≤ S) (hcharge : R + L + S + 8 ≤ charge) |
| (fuel : ℕ) (s : σ) (buf : Array α) (q budget : ℕ) |
| (out : TieBuffer.Result α σ) (left : ℕ) |
| (h : (execute charge read key cells K fuel s buf q budget).1 = some (out, left)) : |
| (execute charge read key cells K fuel s buf q budget).2 ≤ budget - left := by |
| induction fuel generalizing s buf q budget out left with |
| | zero => |
| rw [execute] at h ⊢ |
| split at h |
| next hb => |
| simp only [hb, ↓reduceIte] at h ⊢ |
| cases h |
| omega |
| next _ => contradiction |
| | succ fuel ih => |
| have hread := hr s |
| rw [execute] at h ⊢ |
| split at h |
| next hb => |
| simp only [hb, ↓reduceIte] at h ⊢ |
| cases hv : (read s).1 with |
| | none => |
| simp only [hv] at h ⊢ |
| cases h |
| omega |
| | some p => |
| rcases p with ⟨x, s'⟩ |
| have hkey := hk x |
| have hcell := hs x |
| simp only [hv] at h ⊢ |
| by_cases he : (key x).1 = K |
| · simp only [he, ↓reduceIte] at h ⊢ |
| have hi := ih s' (buf.push x) (q + 1) (budget - charge) out left h |
| have hl := (execute_value charge read key cells K fuel s' (buf.push x) |
| (q + 1) (budget - charge) out left h).2 |
| omega |
| · simp only [he, ↓reduceIte] at h ⊢ |
| cases h |
| omega |
| next _ => contradiction |
|
|
| / |
| theorem execute_remaining (charge : ℕ) (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (cells : α → ℕ) (K : ℤ) |
| (fuel : ℕ) (s : σ) (buf : Array α) (q budget : ℕ) |
| (out : TieBuffer.Result α σ) (left : ℕ) |
| (h : (execute charge read key cells K fuel s buf q budget).1 = some (out, left)) : |
| budget ≤ left + charge * (out.queries - q + 1) := by |
| induction fuel generalizing s buf q budget out left with |
| | zero => |
| rw [execute] at h |
| split at h |
| next hb => |
| cases h |
| simp only [Nat.sub_self, Nat.zero_add, Nat.mul_one] |
| omega |
| next _ => contradiction |
| | succ fuel ih => |
| rw [execute] at h |
| split at h |
| next hb => |
| cases hv : (read s).1 with |
| | none => |
| simp only [hv] at h |
| cases h |
| have hq : q + 1 - q + 1 = 2 := by omega |
| change budget ≤ budget - charge + charge * (q + 1 - q + 1) |
| rw [hq] |
| omega |
| | some p => |
| rcases p with ⟨x, s'⟩ |
| simp only [hv] at h |
| split at h |
| next hk => |
| have hi := ih s' (buf.push x) (q + 1) (budget - charge) out left h |
| have he := (execute_value charge read key cells K fuel s' (buf.push x) |
| (q + 1) (budget - charge) out left h).1 |
| have hm := queries_mono read key cells K fuel s' (buf.push x) (q + 1) |
| rw [← he] at hm |
| have hq : out.queries - q + 1 = (out.queries - (q + 1) + 1) + 1 := by omega |
| rw [hq, Nat.mul_add, Nat.mul_one] |
| omega |
| next hk => |
| cases h |
| have hq : q + 1 - q + 1 = 2 := by omega |
| change budget ≤ budget - charge + charge * (q + 1 - q + 1) |
| rw [hq] |
| omega |
| next _ => contradiction |
|
|
| end LowSpaceSubsetSum.BudgetedFill |
|
|
| end OAI |
|
|
