Graph partition (part, block): partition of a graph G into several vertex-induced subgraphs of G.
internal edge: edge such that two vertices are both within the same block
cut edge: edge accross different blocks
Making connected component (in undirected graph) a block will result no cut edge between the blocks.
Graph contraction: a contraction technique for computing properties of graphs in parallel. As a contraction technique, it is used to solve a problem instance by reducing it to a smaller instance of the same problem.
round: each application of the inductive step
quotient graph: the graph after contraction step
super-vertex: a vertex representing a block
graph partitioning problems are typically NP-hard.
General Strategy:
Base case: If the graph is small (e.g., it has no edges), then compute the desired result.
Inductive case:
Partition the graph into blocks.
Recursive step: Recursively solve the problem for the quotient graph.
Expansion step: By using the result for the quotient graph, compute the result for the input graph.
When you contract, there might be multiple edges in the quotient graph connecting two super-vertex. We can choose to remove duplicate or work with multigraph, depending on applications.
The ultimate goal of graph contraction technique is to reduce the size of the graph by a constant fraction (possibly in expectation) at each round of contraction. Graph contraction technique does not specify which contraction strategy to use.
Edge contraction: a graph contraction where blocks being contracted correspond to edges.
Edge partition: a graph partition where each block is either a single vertex or two vertices connected by an edge.
To find edge partition, we need to solve vertex matching problem.
Vertex Matching: pick maximum edges that don't share endpoint, which can be solved in O(|E|\sqrt{|V|}) work.
For edge contraction, we do not need a maximum matching but one that it is sufficiently large.
We will use Vertex Matching as a way to select edges to contract in a round.
Greedy Vertex Matching: it finds a solution within a factor 2 of optimal.
The greedy algorithm is sequential, because each decision depends on previous decisions.
Parallel Vertex Matching: method 1
HEAD
(2) all nearby edges are TAIL
The probability of selecting an edge in a circle-graph is \frac{1}{8}, and so \frac{1}{8} of the edge will be selected in expectation in a circle-graph.
Parallel Vertex Matching: method 2
The expected number of edge selected is \frac{1}{4} in a circle-graph. (Of course, worse as the degree of vertex increase.)
Parallel Vertex Matching: method 3
The expected number of edge selected is \frac{1}{3}.
Edge Partition doesn't work quiet well with vertices with high degree. If there is a vertex with high degree, then only one of its edges can be selected. Star graphs are a canonical example of such graphs, although there are many others.
Edge contraction therefore is not effective for general graphs.
So if we guarantee a fraction of edges will be selected, then contraction will end in O(k\log |E|) rounds with high probability.
Work: O(|E|) since at each round, we have to flip coins on each edge (O(|E|)) and remap vertices (O(|V|)) to create new edges/vertices. This give us root-dominated recurrence W(|E|) = W(\frac{1}{c}|E|) + O(|E|).
Span: O(\log^2 |E|) since at each round we need to filter (O(\log |E|)) edges to create next round's graph.
Stargraph:
center: the center vertex v \in V
satellites: all edges connected from center to center's neighbors
a single vertex, and a single edge are stargraph.
star partition: partition the graph in a way that each block is a vertex-induced subgraph that is a stargraph
Sequential Construction: We can construct a star partition sequentially by iteratively adding stars until the vertices are exhausted
Parallel Construction: randomly assign "leader" (center), if no leader nearby, elect one.
In the case of all vertices are head, we left with |V| many partitions with only 1 vertex. But this is unlikely to happen.
isolated vertex: if a vertex does not have a neighbor.
The parallel approach to star partition is not optimal, because it might not always create the smallest number of stars. This is acceptable for us, because we only need to reduce the size of the graph by some constant factor.
Based on the array-based cost specification for sequences starPartition
is O(|E|+|V|) work and O(\log |V|) span.
For a graph G with n non-isolated vertices, the expected number of satellites in a call to starPartition(G, i)
for any round i is at least n/4. Proof: let v, u be some non-isolated vertex. Then Pr\{v \text{ is a satellite}\} \geq Pr\{T_v\} \cdot Pr\{H_u\} = \frac{1}{4}. So by linear expectation, there must be \geq \frac{1}{4} satelites which will get contracted.
Higher-order (generic) star-contraction algorithm:
base
function specifies the computation in the base case (vertex set)
expand
function computes the result for the larger graph from the quotient graph
Contract the graph into a number of isolated vertices costs O((|V|+|E|)\log |V|) work and O(\log^2|V|) span, assuming
base
: O(|V|) work and O(1) span
expand
: O(|V|+|E|) work and O((|V| + |E|)\log|E|) span
Span: Since non-isolated vertices after contraction is less than \frac{3}{4} before contraction, the contraction will end in O(\log^2|V|) steps.
Work: bounding the number of edges subtraction by \frac{|V|}{4} is not enough since there can be |V|^2 many edges. For non-isolated vertex: W(n, |E|) \leq W(n', |E|) + O(n + |E|) which solves to O(|V| + |E| \log |V|) in expectation. For isolated vertex, we need additional O(|V|\log|V|) work. The combined work is O((|V|+|E|)\log |V|)
// TODO: understand last sentence
Graph Connectivity: finding all of the connected components in undirected graph by specifying vertex set of each component
Throughout this chapter, we use an edge-set representation for graphs
BFS (and DFS) can solve the problem but with O(|V|) span (which is considered to be large). This is because there can be |V| components or simply a chain of |V| vertices.
Instead of simply counting, we can the algorithm to create a set of a set of vertices.
Compared to counting, computing only modified the base case and expansion case.
Table of Content