Compact Representations of Separable Graphs

1
Compact Representations of Separable Graphs

• From a paper of the same title submitted to SODA
  by
• Dan Blandford and Guy Blelloch
• and Ian Kash

2
Standard Graph Representations

• Standard Adjacency List
• - V 2E words O(ElgV) bits
• - V E words if stored as an array
• For arbitrary graphs, lower bound is
• O(E lg (V2/E)) bits, which adjacency list
  meets for sparse graphs, i.e. E O(V)

3
Representations for Planar Graphs that use O(V)
bits

• No Query Support
• - Turan 1984, First to come up with an O(V)
  bit compression scheme
• - Keeler and Westbrook 1995, Improved
  constants
• - Deo and Litow 1998, First use of separators
• - He, Kao and Lu 2000, Optimal high order
  term
• Query Support
• - Jacobson 1989, O( lg V) adjacency queries
• - Munro and Raman 1997, O(1) adjacency
  queries
• - Based on page embeddings and balanced
  parentheses, so not generally applicable

4
Graph Separators

• Formally, a class of Graphs is separable if
• Every member has a cut set of size ßf(V) for
  some ß gt 0 such that
• Each component has at most an vertices for some a
  lt 1
• We concern ourselves with the case f(V) Vc,
  0 lt c lt 1

• A Vertex Separator

• An Edge Separator

5
Classes of Graphs With Small Separators

• Many Interesting and Useful Classes
• - Planar (and all bounded genus)
• - Telephone / Power / Road networks
• - 3D Meshes (Miller et al. 1997)
• - Link Structure of Web

6
Results

• Theory for both edge and vertex separators
• Compress Graphs to O(V) bits
• Meets Lower Bound for Query Times
• - Degree Queries O(1)
• - Adjacency Queries O(1)
• - Neighbor Queries O(D), D Degree
• Implementation for edge separators

7
Main Ideas

• 1) Build separator tree
• 2) Order based on tree
• 3) Compress using difference encoded adjacency
  table
• 4) Use root find tree
• Vertex separators only

8
A Graph and Its Separator Tree
1
1
1
3
2
4
1
3
1
1
1
2
1
2
4
3
4
4
1
3
2
Final Numbering 1 2 3 4
9
Difference Coded Adjacency Table

• Instead of storing absolute numbers, store
  offsets
• i.e. 1,1,3,2,1 instead of 1,2,5,7,8
• Makes numbers stored smaller
• By itself, it offers no advantage

10
Gamma Code

• Variable length encoding with 2 parts
• 1st Part Unary code of length of 2nd part
• 2nd Part Number in binary
• Encoding n takes 2lg(n1)O(lg(n)) bits
• There are other codes with similar properties
  (Ex Delta Code)

11
Theorem Using a difference coded adjacency table
this ordering requires O(V) bits
12
Sketch of Proof

• The maximum distance between the numbers of u and
  v is the number of vertices in their Least Common
  Ancestor in the separator tree (n)
• With Gamma Code this takes O(lg(n)) bits
• Recurrence S(n) 2S(.5n) O(nc lg(n))
• As a geometrically decreasing recurrence, this
  solves to S(V) O(V)

13
Decoding Vertex i in O(1) time
Pointer to Vertex i
Vertex i-1
Degree
Edge 2
Edge 3
Edge 1
Vertex i1

• We can decode lg(V) bits at a time through
  table lookup
• An Edge Takes O(lg(V)) bits, and the degree of
  a vertex for a graph with good edge separators is
  constant
• We decode the entire vertex using a constant
  number of table lookups

14
Problem!

• This assumes we have a pointer to vertex i
• Requires V pointers of lg V bits each O(V
  lgV), but the graph uses only O(V)
• Can afford a pointer to a BLOCK of lg V
  vertices O(lg V V / lg V) O(V)
• Can afford a pointer to a SUBBLOCK of at least k
  lg V bits
• Can afford extra 2 lg V bits per block

15
Getting a Pointer to Vertex i in O(1)
Pointer to Block (calculate as i / lg (V)
Next Block
Previous Block
100110
Pointer to Block
Pointer to Offsets
Flags to determine subblocks. A 1 is the start
of a subblock
Prev. Subblocks
The Process 1) Calculate block number 2)
Identify subblock number 3) Get subblock
offset 4) Add offset to pointer 5) Decode any
Previous vertices (at most k lg V bits)
16
Graphs Used For Testing
17
Experimental Space Results
18
Experimental Time Results
19
Conclusions

• Our Method uses O(V) bits to compress a graph
  with good separators
• On test graphs with good separators, it used less
  than 12 bits per edge, including overhead
• It meets the lower bounds for queries
• With unoptimized table lookup it takes 3 times as
  long to search as a standard adjacency list
  representation and 6 times as long as an array
  based adjacency list

20
Future Work

• Test decoding speed on more graphs
• Optimize decoding
• Allow addition / deletion of edges
• More Efficient Separator Generator
• Implement Vertex Separators

21
Planar Embeddings and Parentheses

• Create a Page Embedding
• Represent vertices and edges as parentheses
• - () for a vertex
• - ( for start of an edge
• - ) close for end
• - Figure on left
• ()((())(()))((())(()))
• No good page embedding algorithm for arbitrary
  graphs