Call subgraphs clusters.

diff --git a/opt.tex b/opt.tex
index 2d7335f00d1c94de71177b87230f8782c51a3214..9de4d64a617cfd05943cdd07d4f3c0c29663d661 100644 (file)
--- a/opt.tex
+++ b/opt.tex
@@ -639,16 +639,16 @@ trick with expanding the vertex~$c$ to~$P$ in the cycle~$C$. Hence $g\not\in\mst
 
 \para
 We still intend to mimic the Iterative Jarn\'\i{}k's algorithm. We will partition the given graph to a~collection~$\C$
 
 \para
 We still intend to mimic the Iterative Jarn\'\i{}k's algorithm. We will partition the given graph to a~collection~$\C$

-of non-overlapping contractible subgraphs and put aside all edges that got corrupted in the process.
+of non-overlapping contractible subgraphs called \df{clusters} and we put aside all edges that got corrupted in the process.

 We recursively compute the MSF of that subgraphs and of the contracted graph. Then we take the
 union of these MSF's and add the corrupted edges. According to the previous lemma, this does not produce
 the MSF of~$G$, but a~sparser graph containing it, on which we can continue.
 
 We can formulate the exact partitioning algorithm and its properties as follows:
 
 We recursively compute the MSF of that subgraphs and of the contracted graph. Then we take the
 union of these MSF's and add the corrupted edges. According to the previous lemma, this does not produce
 the MSF of~$G$, but a~sparser graph containing it, on which we can continue.
 
 We can formulate the exact partitioning algorithm and its properties as follows:
 

-\algn{Partition a~graph to a~collection of contractible subgraphs}\id{partition}%
+\algn{Partition a~graph to a~collection of contractible clusters}\id{partition}%

 \algo
 \algo

-\algin A~graph~$G$ with an~edge comparison oracle, a~parameter~$t$ controlling the size of the subgraphs,
+\algin A~graph~$G$ with an~edge comparison oracle, a~parameter~$t$ controlling the size of the clusters,

   and an~accuracy parameter~$\varepsilon$.
 \:Mark all vertices as ``live''.
 \:$\C\=\emptyset$, $R^\C\=\emptyset$. \cmt{Start with an~empty collection and no corrupted edges.}
   and an~accuracy parameter~$\varepsilon$.
 \:Mark all vertices as ``live''.
 \:$\C\=\emptyset$, $R^\C\=\emptyset$. \cmt{Start with an~empty collection and no corrupted edges.}


@@ -663,33 +663,33 @@ We can formulate the exact partitioning algorithm and its properties as follows:
 \:::$T\=T\cup\{v\}$.
 \:::If $v$ is dead, break out of the current loop.
 \:::Insert all edges incident with~$v$ to the heap.
 \:::$T\=T\cup\{v\}$.
 \:::If $v$ is dead, break out of the current loop.
 \:::Insert all edges incident with~$v$ to the heap.

-\::$\C\=\C \cup \{G[T]\}$. \cmt{Record the subgraph induced by the tree.}
+\::$\C\=\C \cup \{G[T]\}$. \cmt{Record the cluster induced by the tree.}

 \::\<Explode> the heap and add all remaining corrupted edges to~$K$.
 \::$R^\C\=R^\C \cup K^T$. \cmt{Record the ``interesting'' corrupted edges.}
 \::$G\=G\setminus K^T$. \cmt{Remove the corrupted edges from~$G$.}
 \::Mark all vertices of~$T$ as ``dead''.
 \::\<Explode> the heap and add all remaining corrupted edges to~$K$.
 \::$R^\C\=R^\C \cup K^T$. \cmt{Record the ``interesting'' corrupted edges.}
 \::$G\=G\setminus K^T$. \cmt{Remove the corrupted edges from~$G$.}
 \::Mark all vertices of~$T$ as ``dead''.

-\algout The collection $\C$ of contractible subgraphs and the set~$R^\C$ of
-corrupted edges in the neighborhood of these subgraphs.
+\algout The collection $\C$ of contractible clusters and the set~$R^\C$ of
+corrupted edges in the neighborhood of these clusters.

 \endalgo
 
 \endalgo
 

-\thmn{Partitioning to contractible subgraphs, Chazelle \cite{chazelle:almostacker}}\id{partthm}%
+\thmn{Partitioning to contractible clusters, Chazelle \cite{chazelle:almostacker}}\id{partthm}%

 Given a~weighted graph~$G$ and parameters $\varepsilon$ ($0<\varepsilon\le 1/2$)
 and~$t$, the Partition algorithm (\ref{partition}) constructs a~collection
 Given a~weighted graph~$G$ and parameters $\varepsilon$ ($0<\varepsilon\le 1/2$)
 and~$t$, the Partition algorithm (\ref{partition}) constructs a~collection

-$\C=\{C_1,\ldots,C_k\}$ of subgraphs and a~set~$R^\C$ of edges such that:
+$\C=\{C_1,\ldots,C_k\}$ of clusters and a~set~$R^\C$ of edges such that:

 
 \numlist\ndotted
 
 \numlist\ndotted

-\:All the $C_i$'s and the set~$R^\C$ are edge-disjoint.
-\:Each $C_i$ contains at most~$t$ vertices.
-\:Each vertex of~$G$ is contained in at least one~$C_i$.
-\:The connected components of the union of all $C_i$'s have at least~$t$ vertices each,
-  except perhaps for those which are equal to a~connected component of~$G\setminus R^\C$.
+\:All the clusters and the set~$R^\C$ are mutually edge-disjoint.
+\:Each cluster contains at most~$t$ vertices.
+\:Each vertex of~$G$ is contained in at least one cluster.
+\:The connected components of the union of all clusters have at least~$t$ vertices each,
+  except perhaps for those which are equal to a~connected component of $G\setminus R^\C$.

 \:$\vert R^\C\vert \le 2\varepsilon m$.
 \:$\msf(G) \subseteq \bigcup_i \msf(C_i) \cup \msf\bigl((G / \bigcup_i C_i) \setminus R^\C\bigr) \cup R^\C$.
 \:The algorithm runs in time $\O(n+m\log (1/\varepsilon))$.
 \endlist
 
 \proof
 \:$\vert R^\C\vert \le 2\varepsilon m$.
 \:$\msf(G) \subseteq \bigcup_i \msf(C_i) \cup \msf\bigl((G / \bigcup_i C_i) \setminus R^\C\bigr) \cup R^\C$.
 \:The algorithm runs in time $\O(n+m\log (1/\varepsilon))$.
 \endlist
 
 \proof

-Claim~1: The Partition algorithm grows a~series of trees which induce the subgraphs~$C_i$ in~$G$.
+Claim~1: The Partition algorithm grows a~series of trees which induce the clusters~$C_i$ in~$G$.

 A~tree is built from edges adjacent to live vertices
 and once it is finished, all vertices of the tree die, so no edge is ever reused in another
 tree. The edges that enter~$R^\C$ are immediately deleted from the graph, so they never participate
 A~tree is built from edges adjacent to live vertices
 and once it is finished, all vertices of the tree die, so no edge is ever reused in another
 tree. The edges that enter~$R^\C$ are immediately deleted from the graph, so they never participate


@@ -719,15 +719,15 @@ $$\msf(G) \subseteq \bigcup_i \msf(C_i) \cup \msf\biggl( \bigl(G / \bigcup_i C_i
 
 \proof
 By iterating the Robust contraction lemma (\ref{robcont}). Let $K_i$ be the set of edges
 
 \proof
 By iterating the Robust contraction lemma (\ref{robcont}). Let $K_i$ be the set of edges

-corrupted when constructing the subgraph~$C_i$ in the $i$-th phase of the algorithm,
+corrupted when constructing the cluster~$C_i$ in the $i$-th phase of the algorithm,

 and similarly for the state of the other variables at that time.
 We will use induction on~$i$ to prove that the lemma holds at the end of every phase.
 
 At the beginning, the statement is obviously true, even as an~equality.
 and similarly for the state of the other variables at that time.
 We will use induction on~$i$ to prove that the lemma holds at the end of every phase.
 
 At the beginning, the statement is obviously true, even as an~equality.

-In the $i$-th phase we construct the subgraph~$C_i$ by running the partial Jarn\'\i{}k's algorithm on the graph
+In the $i$-th phase we construct the cluster~$C_i$ by running the partial Jarn\'\i{}k's algorithm on the graph

 $G_i = G\setminus\bigcup_{j<i} K_{\smash j}^{C_j}$.
 $G_i = G\setminus\bigcup_{j<i} K_{\smash j}^{C_j}$.

-If it were not for corruption, the subgraph~$C_i$ would be contractible, as we already know from Example \ref{jarniscont}.
-When the edges in~$K_i$ get corrupted, the subgraph is contractible in some corrupted graph
+If it were not for corruption, the cluster~$C_i$ would be contractible, as we already know from Example \ref{jarniscont}.
+When the edges in~$K_i$ get corrupted, the cluster is contractible in some corrupted graph

 $G_i \crpt K_i$. (We have to be careful as the edges are becoming corrupted gradually,
 but it is easy to check that it can only improve the situation.) Since $C_i$~shares no edges
 with~$C_j$ for any~$j<i$, we know that~$C_i$ also a~contractible subgraph of $(G_i / \bigcup_{j<i} C_j) \crpt K_i$.
 $G_i \crpt K_i$. (We have to be careful as the edges are becoming corrupted gradually,
 but it is easy to check that it can only improve the situation.) Since $C_i$~shares no edges
 with~$C_j$ for any~$j<i$, we know that~$C_i$ also a~contractible subgraph of $(G_i / \bigcup_{j<i} C_j) \crpt K_i$.


@@ -743,7 +743,7 @@ This completes the induction step, because $K_j^{C_j} = K_j^{\C_j}$ for all~$j$.
 The Partition algorithm runs in time $\O(n+m\log(1/\varepsilon))$.
 
 \proof
 The Partition algorithm runs in time $\O(n+m\log(1/\varepsilon))$.
 
 \proof

-The inner loop (steps 7--13) processes the edges of the current subgraph~$C_i$ and also
+The inner loop (steps 7--13) processes the edges of the current cluster~$C_i$ and also

 the edges in its neighborhood $\delta(C_i)$. Steps 6 and~13 insert every such edge to the heap
 at most once, so steps 8--12 visit each edge also at most once. For every edge, we spend
 $\O(\log(1/\varepsilon))$ time amortized on inserting it and $\O(1)$ on the other operations
 the edges in its neighborhood $\delta(C_i)$. Steps 6 and~13 insert every such edge to the heap
 at most once, so steps 8--12 visit each edge also at most once. For every edge, we spend
 $\O(\log(1/\varepsilon))$ time amortized on inserting it and $\O(1)$ on the other operations


@@ -751,7 +751,7 @@ $\O(\log(1/\varepsilon))$ time amortized on inserting it and $\O(1)$ on the othe
 
 Each edge of~$G$ can participate in some $C_i\cup \delta(C_i)$ only twice before both its
 endpoints die. The inner loop therefore processes $\O(m)$ edges total, so it takes $\O(m\log(1/\varepsilon))$
 
 Each edge of~$G$ can participate in some $C_i\cup \delta(C_i)$ only twice before both its
 endpoints die. The inner loop therefore processes $\O(m)$ edges total, so it takes $\O(m\log(1/\varepsilon))$

-time. The remaining parts of the algorithm spend $\O(m)$ time on operations with subgraphs and corrupted edges
+time. The remaining parts of the algorithm spend $\O(m)$ time on operations with clusters and corrupted edges

 and additionally $\O(n)$ on identifying the live vertices.
 \qed
 
 and additionally $\O(n)$ on identifying the live vertices.
 \qed
 


@@ -897,7 +897,7 @@ iff they are edge-disjoint, their union is the whole graph~$G$ and
 $\msf(G) = \bigcup_i \msf(C_i)$ for every permutation of edge weights.
 
 \lemma\id{partiscomp}%
 $\msf(G) = \bigcup_i \msf(C_i)$ for every permutation of edge weights.
 
 \lemma\id{partiscomp}%

-The subgraphs $C_1,\ldots,C_k$ generated by the Partition procedure of the
+The clusters $C_1,\ldots,C_k$ generated by the Partition procedure of the

 previous section (Algorithm \ref{partition}) are compartments of the graph
 $H=\bigcup_i C_i$.
 
 previous section (Algorithm \ref{partition}) are compartments of the graph
 $H=\bigcup_i C_i$.
 


@@ -909,11 +909,11 @@ is the union of the MSF's of the individual compartments. By the Cycle rule
 it is the heaviest edge on some cycle. It is therefore sufficient to prove that
 every cycle in~$H$ is contained within a~single~$C_i$.
 
 it is the heaviest edge on some cycle. It is therefore sufficient to prove that
 every cycle in~$H$ is contained within a~single~$C_i$.
 

-Let us consider a~cycle $K\subseteq H$ and a~subgraph~$C_i$ such that it contains
-an~edge~$e$ of~$K$ and all subgraphs constructed later by the procedure do not contain
+Let us consider a~cycle $K\subseteq H$ and a~cluster~$C_i$ such that it contains
+an~edge~$e$ of~$K$ and all clusters constructed later by the procedure do not contain

 any. If $K$~is not fully contained in~$C_i$, we can extend the edge~$e$ to a~maximal
 path contained in both~$K$ and~$C_i$. Since $C_i$ shares at most one vertex with the
 any. If $K$~is not fully contained in~$C_i$, we can extend the edge~$e$ to a~maximal
 path contained in both~$K$ and~$C_i$. Since $C_i$ shares at most one vertex with the

-earlier subgraphs, there can be at most one edge from~$K$ adjacent to the maximal path,
+earlier clusters, there can be at most one edge from~$K$ adjacent to the maximal path,

 which is impossible.
 \qed
 
 which is impossible.
 \qed
 


@@ -960,7 +960,7 @@ a~single~$C_i$ can be made isomorphic to~${\cal D}(C_i)$.
 \qed
 
 \cor\id{dtpart}%
 \qed
 
 \cor\id{dtpart}%

-If $C_1,\ldots,C_k$ are the subgraphs generated by the Partition procedure (Algorithm \ref{partition}),
+If $C_1,\ldots,C_k$ are the clusters generated by the Partition procedure (Algorithm \ref{partition}),

 then $D(\bigcup_i C_i) = \sum_i D(C_i)$.
 
 \proof
 then $D(\bigcup_i C_i) = \sum_i D(C_i)$.
 
 \proof


@@ -991,10 +991,10 @@ chapters will also play their roles.
 We will describe the algorithm as a~recursive procedure. When the procedure is
 called on a~graph~$G$, it sets the parameter~$t$ to roughly $\log^{(3)} n$ and
 it calls the \<Partition> procedure to split the graph into a~collection of
 We will describe the algorithm as a~recursive procedure. When the procedure is
 called on a~graph~$G$, it sets the parameter~$t$ to roughly $\log^{(3)} n$ and
 it calls the \<Partition> procedure to split the graph into a~collection of

-subgraphs of size~$t$ and a~set of corrupted edges. Then it uses precomputed decision
-trees to find the MSF of the subgraphs. The graph obtained by contracting
-the subgraphs is on the other hand dense enough, so that the Iterated Jarn\'\i{}k's
-algorithm runs on it in linear time. Afterwards we combine the MSF's of the subgraphs
+clusters of size~$t$ and a~set of corrupted edges. Then it uses precomputed decision
+trees to find the MSF of the clusters. The graph obtained by contracting
+the clusters is on the other hand dense enough, so that the Iterated Jarn\'\i{}k's
+algorithm runs on it in linear time. Afterwards we combine the MSF's of the clusters

 and of the contracted graphs, we mix in the corrupted edges and run two iterations
 of the Contractive Bor\o{u}vka's algorithm. This guarantees reduction in the number of
 both vertices and edges by a~constant factor, so we can efficiently recurse on the
 and of the contracted graphs, we mix in the corrupted edges and run two iterations
 of the Contractive Bor\o{u}vka's algorithm. This guarantees reduction in the number of
 both vertices and edges by a~constant factor, so we can efficiently recurse on the


@@ -1004,9 +1004,9 @@ resulting graph.
 \algo
 \algin A~connected graph~$G$ with an~edge comparison oracle.
 \:If $G$ has no edges, return an~empty tree.
 \algo
 \algin A~connected graph~$G$ with an~edge comparison oracle.
 \:If $G$ has no edges, return an~empty tree.

-\:$t\=\lfloor\log^{(3)} n\rfloor$. \cmt{the size of subgraphs}
+\:$t\=\lfloor\log^{(3)} n\rfloor$. \cmt{the size of clusters}

 \:Call \<Partition> (\ref{partition}) on $G$ and $t$ with $\varepsilon=1/8$. It returns
 \:Call \<Partition> (\ref{partition}) on $G$ and $t$ with $\varepsilon=1/8$. It returns

-  a~collection~$\C=\{C_1,\ldots,C_k\}$ of subgraphs and a~set~$R^\C$ of corrupted edges.
+  a~collection~$\C=\{C_1,\ldots,C_k\}$ of clusters and a~set~$R^\C$ of corrupted edges.

 \:$F_i \= \mst(C_i)$ for all~$i$, obtained using optimal decision trees.
 \:$G_A \= (G / \bigcup_i C_i) \setminus R^\C$. \cmt{the contracted graph}
 \:$F_A \= \msf(G_A)$ calculated by the Iterated Jarn\'\i{}k's algorithm (\ref{itjar}).
 \:$F_i \= \mst(C_i)$ for all~$i$, obtained using optimal decision trees.
 \:$G_A \= (G / \bigcup_i C_i) \setminus R^\C$. \cmt{the contracted graph}
 \:$F_A \= \msf(G_A)$ calculated by the Iterated Jarn\'\i{}k's algorithm (\ref{itjar}).


@@ -1035,21 +1035,21 @@ The first two steps of the algorithm are trivial as we have linear time at our
 disposal.
 
 By the Partitioning theorem (\ref{partthm}), the call to \<Partition> with~$\varepsilon$
 disposal.
 
 By the Partitioning theorem (\ref{partthm}), the call to \<Partition> with~$\varepsilon$

-set to a~constant takes $\O(m)$ time and it produces a~collection of subgraphs of size
+set to a~constant takes $\O(m)$ time and it produces a~collection of clusters of size

 at most~$t$ and at most $m/4$ corrupted edges. It also guarantees that the
 connected components of the union of the $C_i$'s have at least~$t$ vertices
 (unless there is just a~single component).
 
 To apply the decision trees, we will use the framework of topological computations developed
 at most~$t$ and at most $m/4$ corrupted edges. It also guarantees that the
 connected components of the union of the $C_i$'s have at least~$t$ vertices
 (unless there is just a~single component).
 
 To apply the decision trees, we will use the framework of topological computations developed

-in Section \ref{bucketsort}. We pad all subgraphs in~$\C$ with isolated vertices, so that they
+in Section \ref{bucketsort}. We pad all clusters in~$\C$ with isolated vertices, so that they

 have exactly~$t$ vertices. We use a~computation that labels the graph with a~pointer to
 its optimal decision tree. Then we apply Theorem \ref{topothm} combined with the
 brute-force construction of optimal decision trees from Lemma \ref{odtconst}. Together they guarantee
 have exactly~$t$ vertices. We use a~computation that labels the graph with a~pointer to
 its optimal decision tree. Then we apply Theorem \ref{topothm} combined with the
 brute-force construction of optimal decision trees from Lemma \ref{odtconst}. Together they guarantee

-that we can assign the decision trees to the subgraphs in time:
+that we can assign the decision trees to the clusters in time:

 $$\O\Bigl(\Vert\C\Vert + t^{t(t+2)} \cdot \bigl(2^{2^{4t^2}} + t^2\bigr)\Bigr)
 = \O\Bigl(m + 2^{2^{2^t}}\Bigr)
 = \O(m).$$
 $$\O\Bigl(\Vert\C\Vert + t^{t(t+2)} \cdot \bigl(2^{2^{4t^2}} + t^2\bigr)\Bigr)
 = \O\Bigl(m + 2^{2^{2^t}}\Bigr)
 = \O(m).$$

-Execution of the decision tree on each subgraph~$C_i$ then takes $\O(D(C_i))$ steps.
+Execution of the decision tree on each cluster~$C_i$ then takes $\O(D(C_i))$ steps.

 
 The contracted graph~$G_A$ has at most $n/t = \O(n / \log^{(3)}n)$ vertices and asymptotically
 the same number of edges as~$G$, so according to Corollary \ref{ijdens}, the Iterated Jarn\'\i{}k's
 
 The contracted graph~$G_A$ has at most $n/t = \O(n / \log^{(3)}n)$ vertices and asymptotically
 the same number of edges as~$G$, so according to Corollary \ref{ijdens}, the Iterated Jarn\'\i{}k's