1. Succincter Mihai P ă trașcu unemployed ??

2. Storing trits Store A[1..n] ∈ {1,2,3} n to retrieve any A[i] efficiently Credits: @Max Plank, 2005

3. Storing trits Store A[1..n] ∈ {1,2,3} n to retrieve any A[i] efficiently SpaceTime trivial2nO(1)

4. Storing trits Store A[1..n] ∈ {1,2,3} n to retrieve any A[i] efficiently SpaceTime trivial2nO(1) arithmetic codingn∙log 2 3Õ(n) 0 1 ⅓⅔ “1”“2”“3” “21” “22” “23”

5. Storing trits Store A[1..n] ∈ {1,2,3} n to retrieve any A[i] efficiently SpaceTime trivial2nO(1) arithmetic codingn∙log 2 3Õ(n) block codingn∙log 2 3 + O(n/τ)Õ(τ) redundancy

6. Storing trits Store A[1..n] ∈ {1,2,3} n to retrieve any A[i] efficiently SpaceTime trivial2nO(1) arithmetic codingn∙log 2 3Õ(n) block codingn∙log 2 3 + O(n/τ)Õ(τ) Hmm… If a block uses O(1) redundancy, the encoding must spread information around Hmm… If a block uses O(1) redundancy, the encoding must spread information around

7. Storing trits Store A[1..n] ∈ {1,2,3} n to retrieve any A[i] efficiently SpaceTime trivial2nO(1) arithmetic codingn∙log 2 3Õ(n) block codingn∙log 2 3 + O(n/τ)Õ(τ) succinct data structuresn∙log 2 3 + O(n/lg n)O(1)

8. Succinct Data Structures “Make data structures use space close to optimum (≈entropy)” dictionaries * classic hash tables use O(n∙lg u) bits * strive for H = log ( u n ) pattern matching * suffix trees use O(n∙lg n) bits * strive for H = n∙lg Σ represent trees with fast navigation (also graphs, etc) * trivial representations use O(n∙lg n) bits * strive for H = lg C n ≈ 2n etc

9. Succinct Data Structures “Make data structures use space close to optimum (≈entropy)” dictionaries * classic hash tables use O(n∙lg u) bits * strive for H = log ( u n ) pattern matching * suffix trees use O(n∙lg n) bits * strive for H = n∙lg Σ represent trees with fast navigation (also graphs, etc) * trivial representations use O(n∙lg n) bits * strive for H = lg C n ≈ 2n etc Down deep, common technique: * blocks of ε lg n elements stored with redundancy ≤1 * tabulation to handle blocks ⇒ Space ≈ H+O(H/(τlg n)) with time O(τ)

10. Storing trits Store A[1..n] ∈ {1,2,3} n to retrieve any A[i] efficiently SpaceTime trivial2nO(1) arithmetic codingn∙log 2 3Õ(n) block codingn∙log 2 3 + O(n/τ)Õ(τ) succinct data structuresn∙log 2 3 + O(n/lg n)O(1) [Golynski et al ’07, ’08]n∙log 2 3 + O(n/lg 2 n)O(1)

11. Storing trits Store A[1..n] ∈ {1,2,3} n to retrieve any A[i] efficiently SpaceTime trivial2nO(1) arithmetic codingn∙log 2 3Õ(n) block codingn∙log 2 3 + O(n/τ)Õ(τ) succinct data structuresn∙log 2 3 + O(n/lg n)O(1) [Golynski et al ’07, ’08]n∙log 2 3 + O(n/lg 2 n)O(1) Here…n∙log 2 3 + O(n/lg τ n)O(τ)

12. Discussion Big new concept: ** use recursion to reduce redundancy ** Many applications: succinct data structures with space O(n/lg c n), ∀ c How am I getting away with improving on a constant?

13. A Succinct Proof

14. Spill-Over Encodings Say I want to represent x ∈ X (think X={1,2,3} B ) If |X| is not a power of 2, how to get redundancy <<1 ? New encoding framework: x ➝ M bits + a spill in {1,..,K} Redundancy = wasted entropy = M + lg K – lg |X| … need to approximate lg|X| ≈ integer + lg(integer) M + lg(K-1) < lg|X| < M + lg K ⇒ redundancy ≤ lg K – lg(K-1) = O(1/K)

15. Recursion {1,2,3} … …… 12..M’ 12..M B=lg n 12..M12 M {1,..,K} B’=(lg n)/(lg K) {1,..,K’}

16. Analysis choose K, K’, K’’, … = Θ( κ ) redundancy at each node = O(1/ κ ) times ≈n nodes ⇒ O(n/ κ ) bits degree B’, B’’, … = Θ( (lg n) / (lg κ ) ) go up until O(n/ κ ) nodes left, then waste 1 bit/node ⇒ query time τ = O(lg B’ κ ) ⇒ κ =((lg n) / τ) τ ⇒ redundancy n / ((lg n) / τ) τ ≈ n/lg τ n

17. Succinct(er) Data Structures

18. A Building Block The “Rank/Select Problem”: Store A[1..n] ∈ {0,1} n subject to: * rank(k): return Σ k i=1 A[i] * select(j): find k such that rank(k)=j [Golynski et al ’07]space n + O(n∙lglg n / lg 2 n), query O(1) [P. FOCS’08]space n + O(n / lg c n), query O(c)

19. The Algorithm A[2] … 12..M(Σ) X = ( B Σ ) A[1] A[B] Σ Σ {1,.., K(Σ)} 12..M {1,.., K’(Σ)} spill H(Σ) + H(A|Σ) = n ⇒ H(Σ) + lg K(Σ) + M ≈ n ⇒ H(spill) ≈ n – M

20. The End Questions?