\nota
Let us analyse the time complexity of this algorithm by studying properties of its \df{recursion tree.}
-The tree describes the subproblems processed by the recursive calls. For any vertex~$t$
-of the tree, we denote the number of vertices and edges of the corresponding subproblem~$G_t$
-by~$n_t$ and~$m_t$ respectively.
-If $m_t>0$, the recursion continues: the left son of~$t$ corresponds to the
-call on the sampled subgraph~$H_t$, the right son to the reduced graph~$G^\prime_t$.
-(Similarly, we use letters subscripted with~$t$ for the state of the other variables
+The tree describes the subproblems processed by the recursive calls. For any vertex~$v$
+of the tree, we denote the number of vertices and edges of the corresponding subproblem~$G_v$
+by~$n_v$ and~$m_v$ respectively.
+If $m_v>0$, the recursion continues: the left son of~$v$ corresponds to the
+call on the sampled subgraph~$H_v$, the right son to the reduced graph~$G^\prime_v$.
+(Similarly, we use letters subscripted with~$v$ for the state of the other variables
of the algorithm.)
The root of the recursion tree is obviously the original graph~$G$, the leaves are
trivial graphs with no edges.
\obs
The Bor\o{u}vka steps together with the removal of isolated vertices guarantee that the number
-of vertices drops at least by a~factor of four in every recursive call. The size of a~subproblem~$G_t$
+of vertices drops at least by a~factor of four in every recursive call. The size of a~subproblem~$G_v$
at level~$i$ is therefore at most $n/4^i$ and the depth of the tree is at most $\lceil\log_4 n\rceil$.
-As there are no more than~$2^i$ subproblems at level~$i$, the sum of all~$n_t$'s
+As there are no more than~$2^i$ subproblems at level~$i$, the sum of all~$n_v$'s
on that level is at most $n/2^i$, which is at most~$2n$ for the whole tree.
We are going to show that the worst case of the KKT algorithm is not worse than
of the plain contractive algorithm, while the average case is linear.
\lemma
-For every subproblem~$G_t$, the KKT algorithm spends time $\O(m_t+n_t)$ plus the time
+For every subproblem~$G_v$, the KKT algorithm spends time $\O(m_v+n_v)$ plus the time
spent on the recursive calls.
\proof
-We know from Lemma \ref{contiter} that each Bor\o{u}vka step takes time $\O(m_t+n_t)$.\foot{We
-add $n_t$ as the graph could be disconnected.}
-The selection of the edges of~$H_t$ is straightforward.
-Finding the $F_t$-heavy edges is not, but we have already shown in Theorem \ref{ramverify}
+We know from Lemma \ref{contiter} that each Bor\o{u}vka step takes time $\O(m_v+n_v)$.\foot{We
+add $n_v$ as the graph could be disconnected.}
+The selection of the edges of~$H_v$ is straightforward.
+Finding the $F_v$-heavy edges is not, but we have already shown in Theorem \ref{ramverify}
that linear time is sufficient on the RAM.
\qed
\proof
The argument for the $\O(n^2)$ bound is similar to the analysis of the plain
-contractive algorithm. As every subproblem~$G_t$ is a~simple graph, the number
-of its edges~$m_t$ is less than~$n_t^2$. By the previous lemma, we spend time
-$\O(n_t^2)$ on it. Summing over all subproblems yields $\sum_t \O(n_t^2) =
-\O((\sum_t n_t)^2) = \O(n^2)$.
+contractive algorithm. As every subproblem~$G_v$ is a~simple graph, the number
+of its edges~$m_v$ is less than~$n_v^2$. By the previous lemma, we spend time
+$\O(n_v^2)$ on it. Summing over all subproblems yields $\sum_v \O(n_v^2) =
+\O((\sum_v n_v)^2) = \O(n^2)$.
In order to prove the $\O(m\log n)$ bound, it is sufficient to show that the total time
-spent on every level of the recursion tree is $\O(m)$. Suppose that $t$~is a~vertex
-of the recursion tree with its left son~$\ell$ and right son~$r$. Some edges of~$G_t$
-are removed in the Bor\o{u}vka steps, let us denote their number by~$b_t$.
-The remaining edges fall either to~$G_\ell = H_t$, or to $G_r = G^\prime_t$, or possibly
+spent on every level of the recursion tree is $\O(m)$. Suppose that $v$~is a~vertex
+of the recursion tree with its left son~$\ell$ and right son~$r$. Some edges of~$G_v$
+are removed in the Bor\o{u}vka steps, let us denote their number by~$b_v$.
+The remaining edges fall either to~$G_\ell = H_v$, or to $G_r = G^\prime_v$, or possibly
to both.
-We can observe that the intersection $G_\ell\cap G_r$ cannot be large: The edges of~$H_t$ that
-are not in the forest~$F_t$ are $F_t$-heavy, so they do not end up in~$G_r$. Therefore the
-intersection can contain only the edges of~$F_t$. As there are at most $n_t/4$ such edges,
-we have $m_\ell + m_r + b_t \le m_t + n_t/4$.
+We can observe that the intersection $G_\ell\cap G_r$ cannot be large: The edges of~$H_v$ that
+are not in the forest~$F_v$ are $F_v$-heavy, so they do not end up in~$G_r$. Therefore the
+intersection can contain only the edges of~$F_v$. As there are at most $n_v/4$ such edges,
+we have $m_\ell + m_r + b_v \le m_v + n_v/4$.
-On the other hand, the first Bor\o{u}vka step selects at least $n_t/2$ edges,
-so $b_t \ge n_t/2$. The duplication of edges between $G_\ell$ and~$G_r$ is therefore
-compensated by the loss of edges by contraction and $m_\ell + m_r \le m_t$. So the total
+On the other hand, the first Bor\o{u}vka step selects at least $n_v/2$ edges,
+so $b_v \ge n_v/2$. The duplication of edges between $G_\ell$ and~$G_r$ is therefore
+compensated by the loss of edges by contraction and $m_\ell + m_r \le m_v$. So the total
number of edges per level does not decrease and it remains to apply the previous lemma.
\qed
son) form a~set of \df{left paths.} Let us consider the expected time spent on
a~single left path. When walking the path downwards from its top vertex~$r$,
the expected size of the subproblems decreases exponentially: for a~son~$\ell$
-of a~vertex~$t$, we have $n_\ell \le n_t/4$ and $\E m_\ell = \E m_t/2$. The
+of a~vertex~$v$, we have $n_\ell \le n_v/4$ and $\E m_\ell = \E m_v/2$. The
expected total time spend on the path is therefore $\O(n_r+m_r)$ and it remains
to sum this over all left paths.
With the exception of the path going from the root of the tree,
-the top~$r$ of a~left path is always a~right son of a~unique parent vertex~$t$.
-Since the subproblem~$G_r$ has been obtained from its parent subproblem~$G_t$
+the top~$r$ of a~left path is always a~right son of a~unique parent vertex~$v$.
+Since the subproblem~$G_r$ has been obtained from its parent subproblem~$G_v$
by filtering out all heavy edges, we can use the Sampling lemma to show that
-$\E m_r \le 2n_t$. The sum of the expected sizes of all top subproblems is
-then $\sum_r n_r + m_r \le \sum_t 3n_t = \O(n)$. After adding the exceptional path
+$\E m_r \le 2n_v$. The sum of the expected sizes of all top subproblems is
+then $\sum_r n_r + m_r \le \sum_v 3n_v = \O(n)$. After adding the exceptional path
from the root, we get $\O(m+n)=\O(m)$.
\qed
requires an~unbounded number of random bits in the worst case.
\rem
-The only place where we needed the power of the RAM is the verification algorithm,
-so we can use the pointer-machine verification algorithm mentioned in Remark \ref{pmverify}
+The only place where we needed the power of the RAM is finding the heavy edges,
+so we can employ the pointer-machine verification algorithm mentioned in Remark \ref{pmverify}
to bring the results of this section to the~PM.
%--------------------------------------------------------------------------------
projects / saga.git / commitdiff