| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.CountedTieGroup |
| import OAI.Combinatorics.LowSpaceSubsetSum.Search.StoppedStreamJoin |
|
|
| namespace OAI |
|
|
| /-! # Costed execution of the stopped sorted-stream join |
|
|
| Every read, key evaluation, callback and snapshot invokes its supplied counted |
| implementation. The resulting work follows the exact stopped query/report/copy |
| ledger. The unused control fuel is never traversed. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.CountedStreamJoin |
|
|
| universe u v s t w |
| variable {α : Type u} {β : Type v} {σ₁ : Type s} {σ₂ : Type t} {τ : Type w} |
|
|
| def potential (M C D : ℕ) (st : StreamJoin.State σ₁ σ₂ τ) : ℕ := |
| M * st.queries + C * st.reports + D * st.copies |
|
|
| def step (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ) |
| (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ) (cells : β → ℕ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (B fuel₁ fuel₂ : ℕ) (s : StreamJoin.State σ₁ σ₂ τ) : |
| StreamJoin.State σ₁ σ₂ τ × ℕ := |
| if s.done then (s, 1) else |
| let fetched₁ := read₁ s.left |
| match fetched₁.1 with |
| | none => ({ s with queries := s.queries + 1, done := true }, fetched₁.2 + 4) |
| | some (x, left') => |
| let fetched₂ := read₂ s.right |
| match fetched₂.1 with |
| | none => ({ s with queries := s.queries + 2, done := true }, fetched₁.2 + fetched₂.2 + 5) |
| | some (y, right') => |
| let k₁ := key₁ x |
| let k₂ := key₂ y |
| let base := fetched₁.2 + fetched₂.2 + k₁.2 + k₂.2 + 8 |
| if k₁.1 < k₂.1 then ({ s with left := left', queries := s.queries + 2 }, base) |
| else if k₂.1 < k₁.1 then ({ s with right := right', queries := s.queries + 2 }, base) |
| else |
| let out := CountedTieGroup.run read₁ key₁ read₂ key₂ cells k₁.1 report clone |
| B fuel₁ fuel₂ s.left s.right s.user |
| (⟨out.1.outer.cursor, out.1.outer.state.last, out.1.outer.state.user, |
| s.queries + 2 + out.1.outer.queries + out.1.fillQueries + out.1.outer.state.queries, |
| s.reports + out.1.outer.state.reports, |
| s.copies + (if out.1.snapshot then 1 else 0) + out.1.outer.state.restores, |
| out.1.outer.halted⟩, base + out.2 + 8) |
|
|
| theorem step_value (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ) |
| (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ) (cells : β → ℕ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (hclone : ∀ s, (clone s).1 = s) |
| (B fuel₁ fuel₂ : ℕ) (s : StreamJoin.State σ₁ σ₂ τ) : |
| (step read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ s).1 = |
| StreamJoin.step (fun s => (read₁ s).1) (fun x => (key₁ x).1) |
| (fun s => (read₂ s).1) (fun y => (key₂ y).1) (fun x y a => (report x y a).1) |
| B fuel₁ fuel₂ s := by |
| by_cases hd : s.done = true |
| · simp only [step, StreamJoin.step, hd, ↓reduceIte] |
| · cases h₁ : (read₁ s.left).1 with |
| | none => simp only [step, StreamJoin.step, hd, Bool.false_eq_true, ↓reduceIte, h₁] |
| | some z₁ => |
| rcases z₁ with ⟨x, left'⟩ |
| cases h₂ : (read₂ s.right).1 with |
| | none => simp only [step, StreamJoin.step, hd, Bool.false_eq_true, ↓reduceIte, h₁, h₂] |
| | some z₂ => |
| rcases z₂ with ⟨y, right'⟩ |
| simp only [step, StreamJoin.step, hd, Bool.false_eq_true, ↓reduceIte, h₁, h₂, |
| CountedTieGroup.run_value read₁ key₁ read₂ key₂ cells _ report clone hclone] |
| split_ifs <;> rfl |
|
|
| theorem step_work_potential |
| (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ) |
| (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ) (cells : β → ℕ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (R₁ R₂ L₁ L₂ S C D : ℕ) |
| (hr₁ : ∀ s, (read₁ s).2 ≤ R₁) (hr₂ : ∀ s, (read₂ s).2 ≤ R₂) |
| (hk₁ : ∀ x, (key₁ x).2 ≤ L₁) (hk₂ : ∀ y, (key₂ y).2 ≤ L₂) |
| (hs : ∀ y, cells y ≤ S) (hc : ∀ x y a, (report x y a).2 ≤ C) |
| (hcopy : ∀ s, (clone s).2 ≤ D) |
| (B fuel₁ fuel₂ : ℕ) (s : StreamJoin.State σ₁ σ₂ τ) : |
| (step read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ s).2 + |
| potential (R₁ + R₂ + L₁ + L₂ + S + 64) C D s ≤ |
| potential (R₁ + R₂ + L₁ + L₂ + S + 64) C D |
| (step read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ s).1 + |
| (R₁ + R₂ + L₁ + L₂ + S + 64) := by |
| by_cases hd : s.done = true |
| · simp only [step, hd, ↓reduceIte] |
| omega |
| · have hr := hr₁ s.left |
| cases h₁ : (read₁ s.left).1 with |
| | none => |
| simp only [step, hd, Bool.false_eq_true, ↓reduceIte, h₁, potential, Nat.mul_add, Nat.mul_one] |
| omega |
| | some z₁ => |
| rcases z₁ with ⟨x, left'⟩ |
| have hr' := hr₂ s.right |
| cases h₂ : (read₂ s.right).1 with |
| | none => |
| simp only [step, hd, Bool.false_eq_true, ↓reduceIte, h₁, h₂, potential, Nat.mul_add] |
| omega |
| | some z₂ => |
| rcases z₂ with ⟨y, right'⟩ |
| have hk := hk₁ x |
| have hk' := hk₂ y |
| have hg := CountedTieGroup.run_work read₁ key₁ read₂ key₂ cells (key₁ x).1 report clone |
| R₁ R₂ L₁ L₂ S C D hr₁ hr₂ hk₁ hk₂ hs hc hcopy B fuel₁ fuel₂ s.left s.right s.user |
| let out := CountedTieGroup.run read₁ key₁ read₂ key₂ cells (key₁ x).1 report clone |
| B fuel₁ fuel₂ s.left s.right s.user |
| change out.2 ≤ (R₁ + R₂ + L₁ + L₂ + S + 50) * |
| (out.1.outer.queries + out.1.fillQueries + out.1.outer.state.queries + 1) + |
| C * out.1.outer.state.reports + |
| D * ((if out.1.snapshot then 1 else 0) + out.1.outer.state.restores) at hg |
| have hmul := Nat.mul_le_mul_right |
| (out.1.outer.queries + out.1.fillQueries + out.1.outer.state.queries + 1) |
| (show R₁ + R₂ + L₁ + L₂ + S + 50 ≤ R₁ + R₂ + L₁ + L₂ + S + 64 by omega) |
| simp only [step, hd, Bool.false_eq_true, ↓reduceIte, h₁, h₂] |
| split |
| · simp only [potential, Nat.mul_add] |
| omega |
| · split |
| · simp only [potential, Nat.mul_add] |
| omega |
| · change (read₁ s.left).2 + (read₂ s.right).2 + (key₁ x).2 + (key₂ y).2 + 8 + out.2 + 8 + |
| potential (R₁ + R₂ + L₁ + L₂ + S + 64) C D s ≤ |
| potential (R₁ + R₂ + L₁ + L₂ + S + 64) C D |
| ⟨out.1.outer.cursor, out.1.outer.state.last, out.1.outer.state.user, |
| s.queries + 2 + out.1.outer.queries + out.1.fillQueries + out.1.outer.state.queries, |
| s.reports + out.1.outer.state.reports, |
| s.copies + (if out.1.snapshot then 1 else 0) + out.1.outer.state.restores, |
| out.1.outer.halted⟩ + _ |
| simp only [potential, Nat.mul_add, Nat.mul_one] at hg hmul ⊢ |
| omega |
|
|
| def runAcc (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ) |
| (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ) (cells : β → ℕ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (B fuel₁ fuel₂ : ℕ) : ℕ → StreamJoin.State σ₁ σ₂ τ → StreamJoin.StoppedResult σ₁ σ₂ τ × ℕ |
| | 0, st => (⟨st, 0⟩, 1) |
| | fuel + 1, st => |
| if st.done then (⟨st, 0⟩, 1) else |
| let next := step read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ st |
| let out := runAcc read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ fuel next.1 |
| (⟨out.1.state, out.1.steps + 1⟩, next.2 + out.2 + 3) |
|
|
| theorem runAcc_value (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ) |
| (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ) (cells : β → ℕ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (hclone : ∀ s, (clone s).1 = s) (B fuel₁ fuel₂ fuel : ℕ) (st : StreamJoin.State σ₁ σ₂ τ) : |
| (runAcc read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ fuel st).1 = |
| StreamJoin.stoppedAcc (fun s => (read₁ s).1) (fun x => (key₁ x).1) |
| (fun s => (read₂ s).1) (fun y => (key₂ y).1) (fun x y a => (report x y a).1) |
| B fuel₁ fuel₂ fuel st := by |
| induction fuel generalizing st with |
| | zero => rfl |
| | succ fuel ih => |
| by_cases hd : st.done = true |
| · simp only [runAcc, StreamJoin.stoppedAcc, hd, ↓reduceIte] |
| · simp only [runAcc, StreamJoin.stoppedAcc, hd, Bool.false_eq_true, ↓reduceIte, ih, |
| step_value read₁ key₁ read₂ key₂ cells report clone hclone] |
|
|
| theorem runAcc_work |
| (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ) |
| (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ) (cells : β → ℕ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (R₁ R₂ L₁ L₂ S C D : ℕ) |
| (hr₁ : ∀ s, (read₁ s).2 ≤ R₁) (hr₂ : ∀ s, (read₂ s).2 ≤ R₂) |
| (hk₁ : ∀ x, (key₁ x).2 ≤ L₁) (hk₂ : ∀ y, (key₂ y).2 ≤ L₂) |
| (hs : ∀ y, cells y ≤ S) (hc : ∀ x y a, (report x y a).2 ≤ C) |
| (hcopy : ∀ s, (clone s).2 ≤ D) |
| (B fuel₁ fuel₂ fuel : ℕ) (st : StreamJoin.State σ₁ σ₂ τ) : |
| (runAcc read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ fuel st).2 + |
| potential (R₁ + R₂ + L₁ + L₂ + S + 64) C D st ≤ |
| potential (R₁ + R₂ + L₁ + L₂ + S + 64) C D |
| (runAcc read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ fuel st).1.state + |
| (R₁ + R₂ + L₁ + L₂ + S + 67) * |
| (runAcc read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ fuel st).1.steps + 1 := by |
| induction fuel generalizing st with |
| | zero => simp only [runAcc, Nat.mul_zero, Nat.add_zero]; omega |
| | succ fuel ih => |
| by_cases hd : st.done = true |
| · simp only [runAcc, hd, ↓reduceIte, Nat.mul_zero, Nat.add_zero]; omega |
| · have hstep := step_work_potential read₁ key₁ read₂ key₂ cells report clone |
| R₁ R₂ L₁ L₂ S C D hr₁ hr₂ hk₁ hk₂ hs hc hcopy B fuel₁ fuel₂ st |
| have hi := ih (step read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ st).1 |
| simp only [runAcc, hd, Bool.false_eq_true, ↓reduceIte, Nat.mul_add, Nat.mul_one] |
| omega |
|
|
| / |
| queries, giving a bound using only the original join ledger. -/ |
| theorem run_work_queries |
| (read₁ : σ₁ → Option (α × σ₁) × ℕ) (key₁ : α → ℤ × ℕ) |
| (read₂ : σ₂ → Option (β × σ₂) × ℕ) (key₂ : β → ℤ × ℕ) (cells : β → ℕ) |
| (report : α → β → τ → (τ × Bool) × ℕ) (clone : σ₂ → σ₂ × ℕ) |
| (hclone : ∀ s, (clone s).1 = s) (R₁ R₂ L₁ L₂ S C D : ℕ) |
| (hr₁ : ∀ s, (read₁ s).2 ≤ R₁) (hr₂ : ∀ s, (read₂ s).2 ≤ R₂) |
| (hk₁ : ∀ x, (key₁ x).2 ≤ L₁) (hk₂ : ∀ y, (key₂ y).2 ≤ L₂) |
| (hs : ∀ y, cells y ≤ S) (hc : ∀ x y a, (report x y a).2 ≤ C) |
| (hcopy : ∀ s, (clone s).2 ≤ D) |
| (B fuel₁ fuel₂ fuel : ℕ) (s₁ : σ₁) (s₂ : σ₂) (a : τ) : |
| (runAcc read₁ key₁ read₂ key₂ cells report clone B fuel₁ fuel₂ fuel |
| (StreamJoin.start s₁ s₂ a)).2 ≤ |
| (2 * (R₁ + R₂ + L₁ + L₂ + S) + 131) * |
| (StreamJoin.run (fun s => (read₁ s).1) (fun x => (key₁ x).1) |
| (fun s => (read₂ s).1) (fun y => (key₂ y).1) (fun x y a => (report x y a).1) |
| B fuel₁ fuel₂ fuel s₁ s₂ a).queries + |
| C * (StreamJoin.run (fun s => (read₁ s).1) (fun x => (key₁ x).1) |
| (fun s => (read₂ s).1) (fun y => (key₂ y).1) (fun x y a => (report x y a).1) |
| B fuel₁ fuel₂ fuel s₁ s₂ a).reports + |
| D * (StreamJoin.run (fun s => (read₁ s).1) (fun x => (key₁ x).1) |
| (fun s => (read₂ s).1) (fun y => (key₂ y).1) (fun x y a => (report x y a).1) |
| B fuel₁ fuel₂ fuel s₁ s₂ a).copies + 1 := by |
| have h := runAcc_work read₁ key₁ read₂ key₂ cells report clone |
| R₁ R₂ L₁ L₂ S C D hr₁ hr₂ hk₁ hk₂ hs hc hcopy B fuel₁ fuel₂ fuel |
| (StreamJoin.start s₁ s₂ a) |
| rw [runAcc_value read₁ key₁ read₂ key₂ cells report clone hclone] at h |
| have hq := StreamJoin.stopped_steps_le_queries (fun s => (read₁ s).1) (fun x => (key₁ x).1) |
| (fun s => (read₂ s).1) (fun y => (key₂ y).1) (fun x y a => (report x y a).1) |
| B fuel₁ fuel₂ fuel s₁ s₂ a |
| have hmul := Nat.mul_le_mul_left (R₁ + R₂ + L₁ + L₂ + S + 67) hq |
| simp only [potential, StreamJoin.start, Nat.mul_zero, Nat.add_zero, |
| StreamJoin.stoppedAcc_eq] at h |
| simp only [StreamJoin.stopped] at hmul |
| dsimp only [StreamJoin.run, StreamJoin.start] at hmul ⊢ |
| have he : 2 * (R₁ + R₂ + L₁ + L₂ + S) + 131 = |
| (R₁ + R₂ + L₁ + L₂ + S + 64) + (R₁ + R₂ + L₁ + L₂ + S + 67) := by omega |
| rw [he, Nat.add_mul] |
| omega |
|
|
| end LowSpaceSubsetSum.CountedStreamJoin |
|
|
| end OAI |
|
|
