File size: 2,976 Bytes
4a56cd6 | 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationPivotWork
namespace OAI
/-! # Binary search with counted predicate evaluations
The predicate is evaluated exactly once at each nonempty interval. The
count includes endpoint arithmetic and the actual predicate callback cost.
-/
namespace LowSpaceSubsetSum.BinaryPivot
variable {n : β}
def measuredStep (p : Fin n β Bool Γ β) (c : Cut n) : Cut n Γ β :=
if h : c.lo < c.hi then
let mid := (c.lo + c.hi) / 2
have hmid : mid < n := by have := c.bounded; dsimp [mid]; omega
let q := p β¨mid, hmidβ©
(if q.1 then
β¨mid + 1, c.hi, by dsimp [mid]; omega, c.boundedβ©
else
β¨c.lo, mid, by dsimp [mid]; omega, by have := c.bounded; dsimp [mid]; omegaβ©,
q.2 + 8)
else (c, 1)
theorem measuredStep_value (p : Fin n β Bool Γ β) (c : Cut n) :
(measuredStep p c).1 = step (fun i => (p i).1) c := by
unfold measuredStep step
split <;> rfl
theorem measuredStep_work (p : Fin n β Bool Γ β) (K : β)
(hp : β i, (p i).2 β€ K) (c : Cut n) :
(measuredStep p c).2 β€ K + 8 := by
unfold measuredStep
split
Β· rename_i h
exact Nat.add_le_add_right (hp β¨(c.lo + c.hi) / 2, by have := c.bounded; omegaβ©) 8
Β· omega
/-- The accumulator makes the search loop tail recursive. -/
def measuredRun (p : Fin n β Bool Γ β) : β β Cut n β β β Cut n Γ β
| 0, c, work => (c, work)
| k + 1, c, work =>
let q := measuredStep p c
measuredRun p k q.1 (work + q.2)
theorem measuredRun_value (p : Fin n β Bool Γ β) (k : β) (c : Cut n) (work : β) :
(measuredRun p k c work).1 = (step (fun i => (p i).1))^[k] c := by
induction k generalizing c work with
| zero => rfl
| succ k ih =>
rw [measuredRun, ih, measuredStep_value, Function.iterate_succ_apply]
theorem measuredRun_work (p : Fin n β Bool Γ β) (K : β)
(hp : β i, (p i).2 β€ K) (k : β) (c : Cut n) (work : β) :
(measuredRun p k c work).2 β€ work + (K + 8) * k := by
induction k generalizing c work with
| zero => simp only [measuredRun, Nat.mul_zero, Nat.add_zero, le_refl]
| succ k ih =>
have hi := ih (measuredStep p c).1 (work + (measuredStep p c).2)
have hs := measuredStep_work p K hp c
change (measuredRun p k (measuredStep p c).1 (work + (measuredStep p c).2)).2 β€ _
simp only [Nat.mul_add, Nat.mul_one]
omega
def measuredSearch (p : Fin n β Bool Γ β) (k : β) : Cut n Γ β :=
measuredRun p k (initial n) 0
theorem measuredSearch_value (p : Fin n β Bool Γ β) (k : β) :
(measuredSearch p k).1 = search (fun i => (p i).1) k := measuredRun_value _ _ _ _
theorem measuredSearch_work (p : Fin n β Bool Γ β) (K : β)
(hp : β i, (p i).2 β€ K) (k : β) :
(measuredSearch p k).2 β€ (K + 8) * k := by
simpa only [measuredSearch, Nat.zero_add] using measuredRun_work p K hp k (initial n) 0
end LowSpaceSubsetSum.BinaryPivot
end OAI
|