Upload
eric-carpenter
View
213
Download
0
Embed Size (px)
Citation preview
Integer Representations and Counting in the Bit Probe Model
M. Zaiur Rahman and J. Ian MunroCheriton School of Computer Science
University of WaterlooWaterloo On
Canada
Integer Representations
• Standard: n bits representing {0..2n}
• # bits … optimal
• Increment: – Θ(n) bit inspections/changes worst case– O(1) amortized, but not if we include
decrement
Redundant Binary Numbers
• Use “digits” 0,1,2 but representation is in binary, 2 is a delayed carrye.g. 01220 = 10100
• Space 2n bits (or reduce to about (lg 3) n)– Increment O(1), as we de-amortize the scan
to release the rightmost carry– Decrement is tricky, easiest to use digit “-1”– Note the extra lg n bits for the scan pointer
Gray Codes .. Due to Gray ..of course
Binary Reflected Gray Code (BRGC)– Of dimension n (i.e. n bits, numbers [0..2n]– A sequence of 2n strings each of length n
G(n) = 0.G(n-1), 1.G(n-1)R
(reversal is on the sequence order, not the individual codes)
Increment on a Gray Code
• Even parity: flip rightmost 1 bit
Increment on a Gray Code
• Even parity: flip rightmost bit
00110000 → 00110001
Increment on a Gray Code
• Even parity: flip rightmost bit
00110000 → 00110001
• Odd parity: flip the bit to left of rightmost 1
01110000 → 01010000
Increment on a Gray Code
• Even parity: flip rightmost bit
00110000 → 00110001
• Odd parity: flip the bit to left of rightmost 1
01110000 → 01010000• Costs:1 bit changed, n inspections (worst case)
• Or: add parity bit, O(1) amortized insert, 2 bits changed
• Integrate parity bit with code (no extra bit [Lucal])
Our First Result: Lower Bound
Theorem: Any representation of [0..2n] using exactly n bits requires Ω(√n) bit inspections in the worst case.
Proof: Model, apply Sunflower Lemma and manipulate
Sunflower Lemma [Ёrdos & Rado]
• Sunflower with p petals– Sets S1, …, Sp so SiSj is same for all i,j
Lemma: S1, …, Sp is a system of sets each of size at most q. If m>(p-1)q+1q!, then it contains a subcollection with p petals
Use the lemma with m as small as possible
Back to Algorithms
• We want a scheme that balances (as well as possible)– Bit changes– Bit inspections– Extra bits
Lower bound says no extra bits lots of inspections
The increment in BRGC
• Key issue … that rightmost 1
Lemma: On increment or decrement, the position of rightmost 1 in any segment of the leftmost bits changes only when that bit is flipped, except for the case of leftmost bit going 1→0 on increment (or 0 → 1 on decrement)
De-amortizing
• The lemma lets us de-amortize: as with redundant binary representation.
With some details:
Theorem: There is a representation using n + lg n + 3 bits (a pointer is in there), requiring 2 lg n +4 bit inspections and 4 bit changes for increment or decrement.
Moving Along
• Complicating issue:Mixing increments and decrements forces us to add flags – (for {inc, dec} and {done yet , not done}
• Idea: use the lower order lg n bits to give the pointer into the leftmost n - lg n bits– This would seem to require a table (or model
issue) to translate
But
• Permute the code of the leading n – lg n bits and use trailing bits directly to walk through them in “code order”
• Indeed, we don’t need n – lg n to be a power of 2
Theorem: There is a representation using n + 3 bits, requiring lg n + 6 bit inspections and 7 bit changes for increment or decrement.
Addition and Subtraction
• Adding or subtracting and m digit (standard notation) integer to update an n digit integer (n > m): – n + O(lg2n) bits, – O(m + lg n) inspections/changes
Open Issues
• Improve the lower bound to n bits inspected in no extra bits
• Lower bound trading off bits changed with space and bits inspected
• Tweaking upper bounds