| import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedReplay |
| import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedReplayLoops |
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.CountedJoinOne |
|
|
| namespace OAI |
|
|
| /-! # Prepaid buffered replay and suffix restoration |
|
|
| The fixed overhead and snapshot allowance are reserved before their operations. |
| The suffix receives only the allowance left by the completed buffer replay. |
| No branch tests the cost of an operation after executing it. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.BudgetedJoinOne |
|
|
| universe u v w |
| variable {α : Type u} {σ : Type v} {τ : Type w} |
|
|
| def execute (charge copyCharge : ℕ) (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (K : ℤ) (report : α → τ → (τ × Bool) × ℕ) |
| (clone : σ → σ × ℕ) (buffer : Array α) (saved : σ) (long : Bool) |
| (fuel : ℕ) (a : τ) (budget : ℕ) : Option (TieReplay.Result σ τ × ℕ) × ℕ := |
| if 6 ≤ budget then |
| let first := BudgetedReplay.execute charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) |
| match first.1 with |
| | none => (none, first.2 + 6) |
| | some (out, left) => |
| if out.halted then |
| (some (⟨saved, out.state, out.queries, out.reports, false, true⟩, left), first.2 + 6) |
| else if long then |
| if copyCharge ≤ left then |
| let copied := clone saved |
| let rest := BudgetedReplay.execute charge read key K report fuel copied.1 |
| out.state 0 0 (left - copyCharge) |
| (rest.1.map (fun (tail, remaining) => |
| (⟨tail.cursor, tail.state, out.queries + tail.queries, |
| out.reports + tail.reports, tail.complete, tail.halted⟩, remaining)), |
| first.2 + copied.2 + rest.2 + 6) |
| else (none, first.2 + 7) |
| else |
| (some (⟨saved, out.state, out.queries, out.reports, true, false⟩, left), first.2 + 6) |
| else (none, 1) |
|
|
| theorem execute_value (charge copyCharge : ℕ) (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (K : ℤ) (report : α → τ → (τ × Bool) × ℕ) |
| (clone : σ → σ × ℕ) (buffer : Array α) (saved : σ) (long : Bool) |
| (fuel : ℕ) (a : τ) (budget : ℕ) (out : TieReplay.Result σ τ) (remaining : ℕ) |
| (h : (execute charge copyCharge read key K report clone buffer saved long fuel a budget).1 = |
| some (out, remaining)) : |
| out = (CountedJoinOne.run read key K report clone buffer saved long fuel a).1 ∧ |
| remaining ≤ budget := by |
| let first := BudgetedReplay.execute charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) |
| have hfirst : BudgetedReplay.execute charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) = first := rfl |
| rw [execute] at h |
| split at h |
| next hb => |
| simp only [hfirst] at h |
| cases hf : first.1 with |
| | none => simp only [hf] at h; contradiction |
| | some p => |
| rcases p with ⟨front, left⟩ |
| have hv := BudgetedReplay.execute_result charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) front left hf |
| obtain ⟨hv, hvleft⟩ := hv |
| change front = (CountedReplay.run _ key K report buffer.size 0 a).1 at hv |
| simp only [hf] at h |
| rw [CountedJoinOne.run, ← hv] |
| split at h |
| next hh => |
| cases h |
| exact ⟨by simp only [hh, ↓reduceIte], hvleft.trans (Nat.sub_le _ _)⟩ |
| next hh => |
| simp only [hh, Bool.false_eq_true, ↓reduceIte] |
| split at h |
| next hl => |
| simp only [hl, ↓reduceIte] |
| split at h |
| next hc => |
| dsimp only at h |
| obtain ⟨pair, hp, he⟩ := Option.map_eq_some_iff.mp h |
| rcases pair with ⟨tail, rest⟩ |
| have ht := BudgetedReplay.execute_result charge read key K report fuel (clone saved).1 |
| front.state 0 0 (left - copyCharge) tail rest hp |
| cases he |
| exact ⟨by rw [ht.1]; rfl, |
| ht.2.trans ((Nat.sub_le _ _).trans (hvleft.trans (Nat.sub_le _ _)))⟩ |
| next _ => contradiction |
| next hl => |
| cases h |
| exact ⟨by simp only [hl, Bool.false_eq_true, ↓reduceIte], |
| hvleft.trans (Nat.sub_le _ _)⟩ |
| next _ => contradiction |
|
|
| / |
| plus its final failed comparison. -/ |
| theorem execute_work (read : σ → Option (α × σ) × ℕ) (key : α → ℤ × ℕ) (K : ℤ) |
| (report : α → τ → (τ × Bool) × ℕ) (clone : σ → σ × ℕ) |
| (R L C charge copyCharge : ℕ) (hr : ∀ s, (read s).2 ≤ R) |
| (hk : ∀ x, (key x).2 ≤ L) (hc : ∀ x a, (report x a).2 ≤ C) |
| (hcharge : max R 4 + L + C + 8 ≤ charge) (hcopy : ∀ s, (clone s).2 ≤ copyCharge) |
| (buffer : Array α) (saved : σ) (long : Bool) (fuel : ℕ) (a : τ) (budget : ℕ) : |
| (execute charge copyCharge read key K report clone buffer saved long fuel a budget).2 ≤ |
| budget + 1 := by |
| have hcb : 4 + L + C + 8 ≤ charge := by omega |
| have hcr : R + L + C + 8 ≤ charge := by omega |
| let first := BudgetedReplay.execute charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) |
| have hfirst : BudgetedReplay.execute charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) = first := rfl |
| have hw := BudgetedReplay.execute_work (fun i => (BufferReplay.read buffer i, 4)) key K report |
| 4 L C charge (fun _ => le_rfl) hk hc hcb buffer.size 0 a 0 0 (budget - 6) |
| change first.2 ≤ budget - 6 + 1 at hw |
| rw [execute] |
| split |
| next hb => |
| simp only [hfirst] |
| cases hf : first.1 with |
| | none => (try dsimp only); omega |
| | some p => |
| rcases p with ⟨front, left⟩ |
| have hv := BudgetedReplay.execute_result charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) front left hf |
| have hs := BudgetedReplay.execute_spent (fun i => (BufferReplay.read buffer i, 4)) key K report |
| 4 L C charge (fun _ => le_rfl) hk hc hcb buffer.size 0 a 0 0 (budget - 6) front left hf |
| change first.2 ≤ budget - 6 - left at hs |
| dsimp only |
| split |
| · (try dsimp only); omega |
| · split |
| · split |
| · have ht := BudgetedReplay.execute_work read key K report R L C charge hr hk hc hcr |
| fuel (clone saved).1 front.state 0 0 (left - copyCharge) |
| have hcp := hcopy saved |
| try dsimp only |
| omega |
| · (try dsimp only); omega |
| · (try dsimp only); omega |
| next _ => (try dsimp only); omega |
|
|
| / |
| theorem execute_spent (read : σ → Option (α × σ) × ℕ) (key : α → ℤ × ℕ) (K : ℤ) |
| (report : α → τ → (τ × Bool) × ℕ) (clone : σ → σ × ℕ) |
| (R L C charge copyCharge : ℕ) (hr : ∀ s, (read s).2 ≤ R) |
| (hk : ∀ x, (key x).2 ≤ L) (hc : ∀ x a, (report x a).2 ≤ C) |
| (hcharge : max R 4 + L + C + 8 ≤ charge) (hcopy : ∀ s, (clone s).2 ≤ copyCharge) |
| (buffer : Array α) (saved : σ) (long : Bool) (fuel : ℕ) (a : τ) (budget : ℕ) |
| (out : TieReplay.Result σ τ) (remaining : ℕ) |
| (h : (execute charge copyCharge read key K report clone buffer saved long fuel a budget).1 = |
| some (out, remaining)) : |
| (execute charge copyCharge read key K report clone buffer saved long fuel a budget).2 ≤ |
| budget - remaining := by |
| have hcb : 4 + L + C + 8 ≤ charge := by omega |
| have hcr : R + L + C + 8 ≤ charge := by omega |
| let first := BudgetedReplay.execute charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) |
| have hfirst : BudgetedReplay.execute charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) = first := rfl |
| rw [execute] at h ⊢ |
| split at h |
| next hb => |
| simp only [hb, ↓reduceIte, hfirst] at h ⊢ |
| cases hf : first.1 with |
| | none => simp only [hf] at h; contradiction |
| | some p => |
| rcases p with ⟨front, left⟩ |
| have hv := BudgetedReplay.execute_result charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) front left hf |
| have hs := BudgetedReplay.execute_spent (fun i => (BufferReplay.read buffer i, 4)) key K report |
| 4 L C charge (fun _ => le_rfl) hk hc hcb buffer.size 0 a 0 0 (budget - 6) front left hf |
| change first.2 ≤ budget - 6 - left at hs |
| simp only [hf] at h ⊢ |
| split at h |
| next hh => |
| simp only [hh, ↓reduceIte] |
| cases h |
| try dsimp only |
| omega |
| next hh => |
| simp only [hh, Bool.false_eq_true, ↓reduceIte] at h ⊢ |
| split at h |
| next hl => |
| simp only [hl, ↓reduceIte] at h ⊢ |
| split at h |
| next hp => |
| simp only [hp, ↓reduceIte] at h ⊢ |
| obtain ⟨pair, ht, he⟩ := Option.map_eq_some_iff.mp h |
| rcases pair with ⟨tail, rest⟩ |
| have hrst := BudgetedReplay.execute_spent read key K report R L C charge hr hk hc hcr |
| fuel (clone saved).1 front.state 0 0 (left - copyCharge) tail rest ht |
| have hrleft := (BudgetedReplay.execute_result charge read key K report fuel |
| (clone saved).1 front.state 0 0 (left - copyCharge) tail rest ht).2 |
| have hcp := hcopy saved |
| cases he |
| try dsimp only |
| omega |
| next _ => contradiction |
| next hl => |
| simp only [hl, Bool.false_eq_true, ↓reduceIte] |
| cases h |
| try dsimp only |
| omega |
| next _ => contradiction |
|
|
| / |
| by multiplying the two advertised stream fuel bounds. -/ |
| theorem execute_complete (charge copyCharge : ℕ) (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (K : ℤ) (report : α → τ → (τ × Bool) × ℕ) |
| (clone : σ → σ × ℕ) (buffer : Array α) (saved : σ) (long : Bool) |
| (fuel : ℕ) (a : τ) (budget : ℕ) |
| (hbudget : charge * ((CountedJoinOne.run read key K report clone buffer saved long fuel a).1.queries + 2) + |
| (if long then copyCharge else 0) + 6 ≤ budget) : |
| ∃ remaining, (execute charge copyCharge read key K report clone buffer saved long fuel a budget).1 = |
| some ((CountedJoinOne.run read key K report clone buffer saved long fuel a).1, remaining) := by |
| let front := (CountedReplay.run (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a).1 |
| have hfdef : (CountedReplay.run (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a).1 = front := rfl |
| have hq : front.queries ≤ (CountedJoinOne.run read key K report clone buffer saved long fuel a).1.queries := by |
| simp only [CountedJoinOne.run, hfdef] |
| split |
| · exact le_rfl |
| · split |
| · (try dsimp only); omega |
| · exact le_rfl |
| have hb : 6 ≤ budget := by omega |
| have hfallow : charge * (front.queries + 1) ≤ budget - 6 := by |
| have hm := Nat.mul_le_mul_left charge (show front.queries + 1 ≤ |
| (CountedJoinOne.run read key K report clone buffer saved long fuel a).1.queries + 2 by omega) |
| omega |
| obtain ⟨left, hfirst⟩ := BudgetedReplay.execute_complete charge |
| (fun i => (BufferReplay.read buffer i, 4)) key K report buffer.size 0 a 0 0 (budget - 6) |
| (by change charge * (front.queries - 0 + 1) ≤ budget - 6 |
| simpa only [Nat.sub_zero] using hfallow) |
| change (BudgetedReplay.execute charge (fun i => (BufferReplay.read buffer i, 4)) key K report |
| buffer.size 0 a 0 0 (budget - 6)).1 = some (front, left) at hfirst |
| have hremaining := BudgetedReplay.execute_remaining charge |
| (fun i => (BufferReplay.read buffer i, 4)) key K report buffer.size 0 a 0 0 (budget - 6) |
| front left hfirst |
| simp only [Nat.sub_zero] at hremaining |
| rw [execute, ite_eq_left hb] |
| simp only [hfirst] |
| by_cases hh : front.halted = true |
| · refine ⟨left, ?_⟩ |
| simp only [hh, ↓reduceIte, CountedJoinOne.run, hfdef] |
| · simp only [hh, Bool.false_eq_true, ↓reduceIte] |
| by_cases hl : long = true |
| · simp only [hl, ↓reduceIte] |
| have hm : charge * ((CountedReplay.run read key K report fuel (clone saved).1 front.state).1.queries + 1) + |
| copyCharge ≤ left := by |
| simp only [CountedJoinOne.run, hfdef, hh, Bool.false_eq_true, hl, ↓reduceIte] at hbudget |
| simp only [Nat.mul_add, Nat.mul_one] at hbudget hremaining ⊢ |
| omega |
| have hcopy : copyCharge ≤ left := by omega |
| rw [ite_eq_left hcopy] |
| obtain ⟨remaining, hrest⟩ := BudgetedReplay.execute_complete charge read key K report |
| fuel (clone saved).1 front.state 0 0 (left - copyCharge) |
| (by simpa only [CountedReplay.run, Nat.sub_zero] using (show |
| charge * ((CountedReplay.run read key K report fuel (clone saved).1 front.state).1.queries + 1) ≤ |
| left - copyCharge by omega)) |
| refine ⟨remaining, ?_⟩ |
| simp only [hrest, Option.map_some, CountedJoinOne.run, hfdef, hh, Bool.false_eq_true, |
| ↓reduceIte] |
| rfl |
| · refine ⟨left, ?_⟩ |
| simp only [hl, Bool.false_eq_true, ↓reduceIte, CountedJoinOne.run, hfdef, hh] |
|
|
| / |
| allowance are discarded by a completed inner replay. -/ |
| theorem execute_remaining (charge copyCharge : ℕ) (read : σ → Option (α × σ) × ℕ) |
| (key : α → ℤ × ℕ) (K : ℤ) (report : α → τ → (τ × Bool) × ℕ) |
| (clone : σ → σ × ℕ) (buffer : Array α) (saved : σ) (long : Bool) |
| (fuel : ℕ) (a : τ) (budget : ℕ) (out : TieReplay.Result σ τ) (remaining : ℕ) |
| (h : (execute charge copyCharge read key K report clone buffer saved long fuel a budget).1 = |
| some (out, remaining)) : |
| budget ≤ remaining + charge * (out.queries + 2) + (if long then copyCharge else 0) + 6 := by |
| let first := BudgetedReplay.execute charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) |
| have hfirst : BudgetedReplay.execute charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) = first := rfl |
| rw [execute] at h |
| split at h |
| next hb => |
| simp only [hfirst] at h |
| cases hf : first.1 with |
| | none => simp only [hf] at h; contradiction |
| | some p => |
| rcases p with ⟨front, left⟩ |
| have hs := BudgetedReplay.execute_remaining charge (fun i => (BufferReplay.read buffer i, 4)) |
| key K report buffer.size 0 a 0 0 (budget - 6) front left hf |
| simp only [Nat.sub_zero, Nat.mul_add, Nat.mul_one] at hs |
| simp only [hf] at h |
| split at h |
| next hh => |
| cases h |
| simp only [Nat.mul_add] |
| omega |
| next hh => |
| split at h |
| next hl => |
| split at h |
| next hp => |
| obtain ⟨pair, ht, he⟩ := Option.map_eq_some_iff.mp h |
| rcases pair with ⟨tail, rest⟩ |
| have hrst := BudgetedReplay.execute_remaining charge read key K report fuel |
| (clone saved).1 front.state 0 0 (left - copyCharge) tail rest ht |
| simp only [Nat.sub_zero, Nat.mul_add, Nat.mul_one] at hrst |
| cases he |
| simp only [hl, ↓reduceIte, Nat.mul_add] |
| omega |
| next _ => contradiction |
| next hl => |
| cases h |
| simp only [Nat.mul_add] |
| omega |
| next _ => contradiction |
|
|
| end LowSpaceSubsetSum.BudgetedJoinOne |
|
|
| end OAI |
|
|
