File size: 4,137 Bytes
e5a97c6 | 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 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 | import OAI.Combinatorics.LowSpaceSubsetSum.Streams.DistinctStreamCount
namespace OAI
/-! # Tail-recursive distinct counting with measured reader calls
Only the current reader state, previous key, count, remaining fuel and work
counter survive each iteration. No list of emitted keys is constructed.
-/
namespace LowSpaceSubsetSum.MeasuredDistinctCount
variable {α σ : Type*}
def loop (read : σ → Option (α × σ) × ℕ) (key : α → ℤ × ℕ) :
ℕ → σ → Option ℤ → ℕ → ℕ → ℕ × ℕ
| 0, _, _, count, work => (count, work + 1)
| fuel + 1, state, previous, count, work =>
let out := read state
match out.1 with
| none => (count, work + out.2 + 1)
| some (x, next) =>
let k := key x
let fresh := match previous with | none => true | some p => decide (p ≠ k.1)
loop read key fuel next (some k.1) (count + if fresh then 1 else 0)
(work + out.2 + k.2 + 3)
theorem loop_value (read : σ → Option (α × σ) × ℕ) (key : α → ℤ × ℕ)
(fuel : ℕ) (s : σ) (previous : Option ℤ) (count work : ℕ) :
(loop read key fuel s previous count work).1 = count +
match previous with
| none => (DistinctStreamCount.run (fun s => (read s).1) (fun x => (key x).1) fuel s).1
| some p => (DistinctStreamCount.tail (fun s => (read s).1) (fun x => (key x).1) fuel s p).1 := by
induction fuel generalizing s previous count work with
| zero => cases previous <;> simp only [loop, DistinctStreamCount.run, DistinctStreamCount.tail, Nat.add_zero]
| succ fuel ih =>
cases previous with
| none =>
cases hr : (read s).1 with
| none => simp only [loop, hr, DistinctStreamCount.run, Nat.add_zero]
| some out =>
rcases out with ⟨x, next⟩
simp only [loop, hr, ↓reduceIte, ih, DistinctStreamCount.run]
omega
| some p =>
cases hr : (read s).1 with
| none => simp only [loop, hr, DistinctStreamCount.tail, Nat.add_zero]
| some out =>
rcases out with ⟨x, next⟩
by_cases he : p = (key x).1
· subst p
simp only [loop, hr, ne_eq, not_true_eq_false, decide_false, Bool.false_eq_true,
↓reduceIte, Nat.add_zero, ih, DistinctStreamCount.tail]
· simp only [loop, hr, ne_eq, he, not_false_eq_true, decide_true, ↓reduceIte,
ih, DistinctStreamCount.tail]
omega
theorem loop_work (read : σ → Option (α × σ) × ℕ) (key : α → ℤ × ℕ)
(R K : ℕ) (hread : ∀ s, (read s).2 ≤ R) (hkey : ∀ x, (key x).2 ≤ K)
(fuel : ℕ) (s : σ) (previous : Option ℤ) (count work : ℕ) :
(loop read key fuel s previous count work).2 ≤ work + (R + K + 4) * fuel + 1 := by
induction fuel generalizing s previous count work with
| zero => simp only [loop, Nat.mul_zero, Nat.add_zero, le_refl]
| succ fuel ih =>
have hr := hread s
simp only [loop]
split
· dsimp only
nlinarith only [hr, Nat.zero_le ((R + K + 4) * fuel)]
next x next _ =>
have hk := hkey x
have ht := ih next (some (key x).1)
(count + if (match previous with | none => true | some p => decide (p ≠ (key x).1))
then 1 else 0) (work + (read s).2 + (key x).2 + 3)
nlinarith only [hr, hk, ht]
def run (read : σ → Option (α × σ) × ℕ) (key : α → ℤ × ℕ) (fuel : ℕ) (s : σ) : ℕ × ℕ :=
loop read key fuel s none 0 0
theorem run_value (read : σ → Option (α × σ) × ℕ) (key : α → ℤ × ℕ) (fuel : ℕ) (s : σ) :
(run read key fuel s).1 =
(DistinctStreamCount.run (fun s => (read s).1) (fun x => (key x).1) fuel s).1 := by
simpa only [run, Nat.zero_add] using loop_value read key fuel s none 0 0
theorem run_work (read : σ → Option (α × σ) × ℕ) (key : α → ℤ × ℕ)
(R K : ℕ) (hread : ∀ s, (read s).2 ≤ R) (hkey : ∀ x, (key x).2 ≤ K)
(fuel : ℕ) (s : σ) :
(run read key fuel s).2 ≤ (R + K + 4) * fuel + 1 := by
simpa only [run, Nat.zero_add] using loop_work read key R K hread hkey fuel s none 0 0
end LowSpaceSubsetSum.MeasuredDistinctCount
end OAI
|