+\chapter{Advanced MST Algorithms}
+
+\section{Minor-closed graph classes}\id{minorclosed}%
+
+The contractive algorithm given in Section~\ref{contalg} has been found to perform
+well on planar graphs, but in the general case its time complexity was not linear.
+Can we find any broader class of graphs where this algorithm is still efficient?
+The right context turns out to be the minor-closed graph classes, which are
+closed under contractions and have bounded density.
+
+\defn\id{minordef}%
+A~graph~$H$ is a \df{minor} of a~graph~$G$ (written as $H\minorof G$) iff it can be obtained
+from a~subgraph of~$G$ by a sequence of simple graph contractions.
+
+\defn
+A~class~$\cal C$ of graphs is \df{minor-closed}, when for every $G\in\cal C$ and
+every minor~$H$ of~$G$, the graph~$H$ lies in~$\cal C$ as well. A~class~$\cal C$ is called
+\df{non-trivial} if at least one graph lies in~$\cal C$ and at least one lies outside~$\cal C$.
+
+\example
+Non-trivial minor-closed classes include:
+\itemize\ibull
+\:planar graphs,
+\:graphs embeddable in any fixed surface (i.e., graphs of bounded genus),
+\:graphs embeddable in~${\bb R}^3$ without knots or without interlocking cycles,
+\:graphs of bounded tree-width or path-width.
+\endlist
+
+\para
+Many of the nice structural properties of planar graphs extend to
+minor-closed classes, too (see Lov\'asz \cite{lovasz:minors} for a~nice survey
+of this theory and Diestel \cite{diestel:gt} for some of the deeper results).
+For analysis of the contractive algorithm, we will make use of the bounded
+density of minor-closed classes:
+
+\defn\id{density}%
+Let $G$ be a~graph and $\cal C$ be a class of graphs. We define the \df{edge density}
+$\varrho(G)$ of~$G$ as the average number of edges per vertex, i.e., $m(G)/n(G)$. The
+edge density $\varrho(\cal C)$ of the class is then defined as the infimum of $\varrho(G)$ over all $G\in\cal C$.
+
+\thmn{Density of minor-closed classes, Mader~\cite{mader:dens}}
+Every non-trivial minor-closed class of graphs has finite edge density.
+
+\thmn{MST on minor-closed classes, Mare\v{s} \cite{mm:mst}}\id{mstmcc}%
+For any fixed non-trivial minor-closed class~$\cal C$ of graphs, the Contractive Bor\o{u}vka's
+algorithm (\ref{contbor}) finds the MST of any graph of this class in time
+$\O(n)$. (The constant hidden in the~$\O$ depends on the class.)
+
+\paran{Local contractions}\id{nobatch}%
+The contractive algorithm uses ``batch processing'' to perform many contractions
+in a single step. It is also possible to perform them one edge at a~time,
+batching only the flattenings. A~contraction of an edge~$uv$ can be done in time~$\O(\deg(u))$,
+so we have to make sure that there is a~steady supply of low-degree vertices.
+It indeed is in minor-closed classes:
+
+\lemman{Low-degree vertices}\id{lowdeg}%
+Let $\cal C$ be a graph class with density~$\varrho$ and $G\in\cal C$ a~graph
+with $n$~vertices. Then at least $n/2$ vertices of~$G$ have degree at most~$4\varrho$.
+
+So we get the following algorithm:
+
+\algn{Local Bor\o{u}vka's Algorithm, Mare\v{s} \cite{mm:mst}}%
+\algo
+\algin A~graph~$G$ with an edge comparison oracle and a~parameter~$t\in{\bb N}$.
+\:$T\=\emptyset$.
+\:$\ell(e)\=e$ for all edges~$e$.
+\:While $n(G)>1$:
+\::While there exists a~vertex~$v$ such that $\deg(v)\le t$:
+\:::Select the lightest edge~$e$ incident with~$v$.
+\:::Contract~$e$.
+\:::$T\=T + \ell(e)$.
+\::Flatten $G$, removing parallel edges and loops.
+\algout Minimum spanning tree~$T$.
+\endalgo
+
+\thm
+When $\cal C$ is a minor-closed class of graphs with density~$\varrho$, the
+Local Bor\o{u}vka's Algorithm with the parameter~$t$ set to~$4\varrho$
+finds the MST of any graph from this class in time $\O(n)$. (The constant
+in the~$\O$ depends on~the class.)
+
+\section{Iterated algorithms}\id{iteralg}%
+
+We have seen that the Jarn\'\i{}k's Algorithm \ref{jarnik} runs in $\Theta(m\log n)$ time.
+Fredman and Tarjan \cite{ft:fibonacci} have shown a~faster implementation using their Fibonacci
+heaps, which runs in time $\O(m+n\log n)$. This is $\O(m)$ whenever the density of the
+input graph reaches $\Omega(\log n)$. This suggests that we could combine the algorithm with
+another MST algorithm, which identifies a~part of the MST edges and contracts
+them to increase the density of the graph. For example, if we perform several Bor\o{u}vka
+steps and then run the Jarn\'\i{}k's algorithm, we find the MST in time $\O(m\log\log n)$.
+
+Actually, there is a~much better choice of the algorithms to combine: use the
+Jarn\'\i{}k's algorithm with a~Fibonacci heap multiple times, each time stopping it after a~while.
+A~good choice of the stopping condition is to place a~limit on the size of the heap.
+We start with an~arbitrary vertex, grow the tree as usually and once the heap gets too large,
+we conserve the current tree and start with a~different vertex and an~empty heap. When this
+process runs out of vertices, it has identified a~sub-forest of the MST, so we can
+contract the edges of~this forest and iterate.
+
+\algn{Iterated Jarn\'\i{}k; Fredman and Tarjan \cite{ft:fibonacci}}\id{itjar}%
+\algo
+\algin A~graph~$G$ with an edge comparison oracle.
+\:$T\=\emptyset$. \cmt{edges of the MST}
+\:$\ell(e)\=e$ for all edges~$e$. \cmt{edge labels as usually}
+\:$m_0\=m$.
+\:While $n>1$: \cmt{We will call iterations of this loop \df{phases}.}
+\::$F\=\emptyset$. \cmt{forest built in the current phase}
+\::$t\=2^{\lceil 2m_0/n \rceil}$. \cmt{the limit on heap size}
+\::While there is a~vertex $v_0\not\in F$:
+\:::Run the Jarn\'\i{}k's algorithm from~$v_0$, stop when:
+\::::all vertices have been processed, or
+\::::a~vertex of~$F$ has been added to the tree, or
+\::::the heap has grown to more than~$t$ elements.
+\:::Denote the resulting tree~$R$.
+\:::$F\=F\cup R$.
+\::$T\=T\cup \ell[F]$. \cmt{Remember MST edges found in this phase.}
+\::Contract all edges of~$F$ and flatten~$G$.
+\algout Minimum spanning tree~$T$.
+\endalgo
+
+\thm\id{itjarthm}%
+The Iterated Jarn\'\i{}k's algorithm finds the MST of the input graph in time
+$\O(m\timesbeta(m,n))$, where $\beta(m,n):=\min\{ i \mid \log^{(i)}n \le m/n \}$.
+
+\cor
+The Iterated Jarn\'\i{}k's algorithm runs in time $\O(m\log^* n)$.
+
+\paran{Integer weights}%
+The algorithm spends most of the time in phases which have small heaps. Once the
+heap grows to $\Omega(\log^{(k)} n)$ for any fixed~$k$, the graph gets dense enough
+to guarantee that at most~$k$ phases remain. This means that if we are able to
+construct a~heap of size $\Omega(\log^{(k)} n)$ with constant time per operation,
+we can get a~linear-time algorithm for MST. This is the case when the weights are
+integers (we can use the Q-heap trees from Section~\ref{ramds}.
+
+\thmn{MST for integer weights, Fredman and Willard \cite{fw:transdich}}\id{intmst}%
+MST of a~graph with integer edge weights can be found in time $\O(m)$ on the Word-RAM.
+
+\section{Verification of minimality}\id{verifysect}%
+
+Now we will turn our attention to a~slightly different problem: given a~spanning
+tree, how to verify that it is minimum? We will show that this can be achieved
+in linear time and it will serve as a~basis for a~randomized linear-time
+MST algorithm in the next section.
+
+MST verification has been studied by Koml\'os \cite{komlos:verify}, who has
+proven that $\O(m)$ edge comparisons are sufficient, but his algorithm needed
+super-linear time to find the edges to compare. Dixon, Rauch and Tarjan \cite{dixon:verify}
+have later shown that the overhead can be reduced
+to linear time on the RAM using preprocessing and table lookup on small
+subtrees. Later, King has given a~simpler algorithm in \cite{king:verifytwo}.
+
+To verify that a~spanning tree~$T$ is minimum, it is sufficient to check that all
+edges outside~$T$ are $T$-heavy. For each edge $uv\in E\setminus T$, we will
+find the heaviest edge of the tree path $T[u,v]$ (we will call it the \df{peak}
+of the path) and compare its weight to $w(uv)$. We have therefore transformed
+the MST verification to the problem of finding peaks for a~set of \df{query
+paths} on a~given tree. By a~sequence of further transformations, we can even
+assume that the given tree is \df{complete branching} (all vertices are on
+the same level and internal vertices always have outdegree~2) and that the
+query paths join a~vertex with one of its ancestors.
+
+Koml\'os has given a~simple algorithm that traverses the complete branching
+tree recursively. At each moment, it maintains an~array of peaks of the restrictions
+of the query paths to the subtree below the current vertex. If we account for the
+comparisons performed by this algorithm carefully and express the bound in terms
+of the size of the original problem (before all the transformations), we get:
+
+\thmn{Verification of the MST, Koml\'os \cite{komlos:verify}}\id{verify}%
+For every weighted graph~$G$ and its spanning tree~$T$, it is sufficient to
+perform $\O(m)$ comparisons of edge weights to determine whether~$T$ is minimum
+and to find all $T$-light edges in~$G$.
+
+It remains to demonstrate that the overhead of the algorithm needed to find
+the required comparisons and infer the peaks from their results can be decreased,
+so that it gets bounded by the number of comparisons and therefore also by $\O(m)$.
+We will follow the idea of King from \cite{king:verifytwo}, but as we have the power
+of the RAM data structures from Section~\ref{ramds} at our command, the low-level
+details will be easier. Still, the construction is rather technical, so we omit
+it in this abstract and state only the final theorem:
+
+\thmn{Verification of MST on the RAM}\id{ramverify}%
+There is a~RAM algorithm which for every weighted graph~$G$ and its spanning tree~$T$
+determines whether~$T$ is minimum and finds all $T$-light edges in~$G$ in time $\O(m)$.
+
+\rem
+Buchsbaum et al.~\cite{buchsbaum:verify} have recently shown that linear-time
+verification can be achieved even on the Pointer Machine.
+They combine an~algorithm of time complexity $\O(m\timesalpha(m,n))$
+based on the Disjoint Set Union data structure with the framework of topological graph
+computations described in Section \ref{bucketsort}.
+The online version of this problem has turned out to be more difficult: there
+is a~super-linear lower bound for it due to Pettie \cite{pettie:onlineverify}.
+
+\section{A randomized algorithm}\id{randmst}%
+
+When we analysed the Contractive Bor\o{u}vka's algorithm in Section~\ref{contalg},
+we observed that while the number of vertices per iteration decreases exponentially,
+the number of edges generally does not, so we spend $\Theta(m)$ time on every phase.
+Karger, Klein and Tarjan \cite{karger:randomized} have overcome this problem by
+combining the Bor\o{u}vka's algorithm with filtering based on random sampling.
+This leads to a~randomized algorithm which runs in linear expected time.
+
+The principle of the filtering is simple: Let us consider any spanning tree~$T$
+of the input graph~$G$. Each edge of~$G$ that is $T$-heavy is the heaviest edge
+of some cycle, so by the Red lemma it cannot participate in
+the MST of~$G$. We can therefore discard all $T$-heavy edges and continue with
+finding the MST on the reduced graph. Of course, not all choices of~$T$ are equally
+good, but it will soon turn out that when we take~$T$ as the MST of a~randomly selected
+subgraph, only a~small expected number of edges remains:
+
+\lemman{Random sampling, Karger \cite{karger:sampling}}\id{samplemma}%
+Let $H$~be a~subgraph of~$G$ obtained by including each edge independently
+with probability~$p$. Let further $F$~be the minimum spanning forest of~$H$. Then the
+expected number of $F$-nonheavy\foot{That is, $F$-light edges and also edges of~$F$ itself.}
+edges in~$G$ is at most $n/p$.
+
+\para
+We will formulate the algorithm as a~doubly-recursive procedure. It alternatively
+performs steps of the Bor\o{u}vka's algorithm and filtering based on the above lemma.
+The first recursive call computes the MSF of the sampled subgraph, the second one
+finds the MSF of the original graph, but without the heavy edges.
+
+\algn{MSF by random sampling --- the KKT algorithm}\id{kkt}%
+\algo
+\algin A~graph $G$ with an~edge comparison oracle.
+\:Remove isolated vertices from~$G$. If no vertices remain, stop and return an~empty forest.
+\:Perform two Bor\o{u}vka steps (iterations of Algorithm \ref{contbor}) on~$G$ and
+ remember the set~$B$ of the edges having been contracted.
+\:Select a~subgraph~$H\subseteq G$ by including each edge independently with
+ probability $1/2$.
+\:$F\=\msf(H)$ calculated recursively.
+\:Construct $G'\subseteq G$ by removing all $F$-heavy edges of~$G$.
+\:$R\=\msf(G')$ calculated recursively.
+\:Return $R\cup B$.
+\algout The minimum spanning forest of~$G$.
+\endalgo
+
+A~careful analysis of this algorithm, based on properties of its recursion tree
+and the peak-finding algorithm of the previous section yields the following time bounds:
+
+\thm
+The KKT algorithm runs in time $\O(\min(n^2,m\log n))$ in the worst case on the RAM.
+
+\thm
+The expected time complexity of the KKT algorithm on the RAM is $\O(m)$.
+
+\chapter{Approaching Optimality}\id{optchap}%
+
+\section{Soft heaps}\id{shsect}%
+
+A~vast majority of MST algorithms that we have encountered so far is based on
+the Tarjan's Blue rule (Lemma \ref{bluelemma}). The rule serves to identify
+edges that belong to the MST, while all other edges are left in the process. This
+unfortunately means that the later stages of computation spend most of
+their time on these edges that never enter the MSF. A~notable exception is the randomized
+algorithm of Karger, Klein and Tarjan. It adds an~important ingredient: it uses
+the Red rule (Lemma \ref{redlemma}) to filter out edges that are guaranteed to stay
+outside the MST, so that the graphs with which the algorithm works get smaller
+with time.
+
+Recently, Chazelle \cite{chazelle:ackermann} and Pettie \cite{pettie:ackermann}
+have presented new deterministic algorithms for the MST which are also based
+on the combination of both rules. They have reached worst-case time complexity
+$\O(m\timesalpha(m,n))$ on the Pointer Machine. We will devote this chapter to their results
+and especially to another algorithm by Pettie and Ramachandran \cite{pettie:optimal}
+which is provably optimal.
+
+At the very heart of all these algorithms lies the \df{soft heap} discovered by
+Chazelle \cite{chazelle:softheap}. It is a~meldable priority queue, roughly
+similar to the Vuillemin's binomial heaps \cite{vuillemin:binheap} or Fredman's
+and Tarjan's Fibonacci heaps \cite{ft:fibonacci}. The soft heaps run faster at
+the expense of \df{corrupting} a~fraction of the inserted elements by raising
+their values (the values are however never lowered). This allows for
+a~trade-off between accuracy and speed, controlled by a~parameter~$\varepsilon$.
+The heap operations take $\O(\log(1/\varepsilon))$ amortized time and at every
+moment at most~$\varepsilon n$ elements of the $n$~elements inserted can be
+corrupted.
+
+\defnn{Soft heap interface}%
+The \df{soft heap} contains a~set of distinct items from a~totally ordered universe and it
+supports the following operations:
+\itemize\ibull
+\:$\<Create>(\varepsilon)$ --- Create an~empty soft heap with the given accuracy parameter~$\varepsilon$.
+\:$\<Insert>(H,x)$ --- Insert a~new item~$x$ into the heap~$H$.
+\:$\<Meld>(P,Q)$ --- Merge two heaps into one, more precisely move all items of a~heap~$Q$
+ to the heap~$P$, destroying~$Q$ in the process. Both heaps must have the same~$\varepsilon$.
+\:$\<DeleteMin>(H)$ --- Delete the minimum item of the heap~$H$ and return its value
+ (optionally signalling that the value has been corrupted).
+\:$\<Explode>(H)$ --- Destroy the heap and return a~list of all items contained in it
+ (again optionally marking those corrupted).
+\endlist
+
+\>We describe the exact mechanics of the soft heaps and analyse its complexity.
+The important properties are summarized in the following theorem:
+
+\thmn{Performance of soft heaps, Chazelle \cite{chazelle:softheap}}\id{softheap}%
+A~soft heap with error rate~$\varepsilon$ ($0<\varepsilon\le 1/2$) processes
+a~sequence of operations starting with an~empty heap and containing $n$~\<Insert>s
+in time $\O(n\log(1/\varepsilon))$ on the Pointer Machine. At every moment, the
+heap contains at most $\varepsilon n$ corrupted items.
+
+\section{Robust contractions}
+
+Having the soft heaps at hand, we would like to use them in a~conventional MST
+algorithm in place of a~normal heap. The most efficient specimen of a~heap-based
+algorithm we have seen so far is the Jarn\'\i{}k's algorithm.
+We can try implanting the soft heap in this algorithm, preferably in the earlier
+version without Fibonacci heaps as the soft heap lacks the \<Decrease> operation.
+This brave, but somewhat simple-minded attempt is however doomed to
+fail. The reason is of course the corruption of items inside the heap, which
+leads to increase of weights of some subset of edges. In presence of corrupted
+edges, most of the theory we have so carefully built breaks down. There is
+fortunately some light in this darkness. While the basic structural properties
+of MST's no longer hold, there is a~weaker form of the Contraction lemma that
+takes the corrupted edges into account. Before we prove this lemma, we expand
+our awareness of subgraphs which can be contracted.
+
+\defn
+A~subgraph $C\subseteq G$ is \df{contractible} iff for every pair of edges $e,f\in\delta(C)$\foot{That is,
+of~$G$'s edges with exactly one endpoint in~$C$.} there exists a~path in~$C$ connecting the endpoints
+of the edges $e,f$ such that all edges on this path are lighter than either $e$ or~$f$.
+
+For example, when we stop the Jarn\'\i{}k's algorithm at some moment and
+we take a~subgraph~$C$ induced by the constructed tree, this subgraph is contractible.
+We can now easily reformulate the Contraction lemma (\ref{contlemma}) in the language
+of contractible subgraphs:
+
+\lemman{Generalized contraction}
+When~$C\subseteq G$ is a~contractible subgraph, then $\msf(G)=\msf(C) \cup \msf(G/C)$.
+
+We can now bring corruption back to the game and state a~``robust'' version
+of this lemma. A~notation for corrupted graphs will be handy:
+
+\nota\id{corrnota}%
+When~$G$ is a~weighted graph and~$R$ a~subset of its edges, we will use $G\crpt
+R$ to denote an arbitrary graph obtained from~$G$ by increasing the weights of
+some of the edges in~$R$.
+Whenever~$C$ is a~subgraph of~$G$, we will use $R^C$ to refer to the edges of~$R$ with
+exactly one endpoint in~$C$ (i.e., $R^C = R\cap \delta(C)$).
+
+\lemman{Robust contraction, Chazelle \cite{chazelle:almostacker}}\id{robcont}%
+Let $G$ be a~weighted graph and $C$~its subgraph contractible in~$G\crpt R$
+for some set~$R$ of edges. Then $\msf(G) \subseteq \msf(C) \cup \msf((G/C) \setminus R^C) \cup R^C$.
+
+\para
+We will mimic the Iterated Jarn\'\i{}k's algorithm. We will partition the given graph to a~collection~$\C$
+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 those 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.
+
+\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$, we can construct a~collection $\C=\{C_1,\ldots,C_k\}$ of clusters and a~set~$R^\C$ of edges such that:
+
+\numlist\ndotted
+\: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 construction takes $\O(n+m\log (1/\varepsilon))$ time.
+\endlist
+
+\section{Decision trees}\id{dtsect}%
+
+The Pettie's and Ramachandran's algorithm combines the idea of robust partitioning with optimal decision
+trees constructed by brute force for very small subgraphs.
+Formally, the decision trees are defined as follows:
+
+\defnn{Decision trees and their complexity}\id{decdef}%
+A~\df{MSF decision tree} for a~graph~$G$ is a~binary tree. Its internal vertices
+are labeled with pairs of $G$'s edges to be compared, each of the two outgoing tree edges
+corresponds to one possible result of the comparison.
+Leaves of the tree are labeled with spanning trees of the graph~$G$.
+
+A~\df{computation} of the decision tree on a~specific permutation of edge weights
+in~$G$ is the path from the root to a~leaf such that the outcome of every comparison
+agrees with the edge weights. The result of the computation is the spanning tree
+assigned to its final leaf.
+A~decision tree is \df{correct} iff for every permutation the corresponding
+computation results in the real MSF of~$G$ with the particular weights.
+
+The \df{time complexity} of a~decision tree is defined as its depth. It therefore
+bounds the number of comparisons spent on every path. (It need not be equal since
+some paths need not correspond to an~actual computation --- the sequence of outcomes
+on the path could be unsatisfiable.)
+
+A~decision tree is called \df{optimal} if it is correct and its depth is minimum possible
+among the correct decision trees for the given graph.
+We will denote an~arbitrary optimal decision tree for~$G$ by~${\cal D}(G)$ and its
+complexity by~$D(G)$.
+
+The \df{decision tree complexity} $D(m,n)$ of the MSF problem is the maximum of~$D(G)$
+over all graphs~$G$ with $n$~vertices and~$m$ edges.
+
+\obs
+Decision trees are the most general deterministic comparison-based computation model possible.
+The only operations that count in its time complexity are comparisons. All
+other computation is free, including solving NP-complete problems or having
+access to an~unlimited source of non-uniform constants. The decision tree
+complexity is therefore an~obvious lower bound on the time complexity of the
+problem in all other comparison-based models.
+
+The downside is that we do not know any explicit construction of the optimal
+decision trees, or at least a~non-constructive proof of their complexity.
+On the other hand, the complexity of any existing comparison-based algorithm
+can be used as an~upper bound on the decision tree complexity. Also, we can
+construct an~optimal decision tree using brute force:
+
+\lemma
+An~optimal MST decision tree for a~graph~$G$ on~$n$ vertices can be constructed on
+the Pointer Machine in time $\O(2^{2^{4n^2}})$.
+
+\section{An optimal algorithm}\id{optalgsect}%
+
+Once we have developed the soft heaps, partitioning and MST decision trees,
+it is now simple to state the Pettie's and Ramachandran's MST algorithm
+and prove that it is asymptotically optimal among all MST algorithms in
+comparison-based models. Several standard MST algorithms from the previous
+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
+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
+resulting graph.
+
+\algn{Optimal MST algorithm, Pettie and Ramachandran \cite{pettie:optimal}}\id{optimal}%
+\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 clusters}
+\:Call \<Partition> (\ref{partition}) on $G$ and $t$ with $\varepsilon=1/8$. It returns
+ 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}).
+\:$G_B \= \bigcup_i F_i \cup F_A \cup R^\C$. \cmt{combine subtrees with corrupted edges}
+\:Run two Bor\o{u}vka steps (iterations of the Contractive Bor\o{u}vka's algorithm, \ref{contbor}) on~$G_B$,
+ getting a~contracted graph~$G_C$ and a~set~$F_B$ of MST edges.
+\:$F_C \= \mst(G_C)$ obtained by a~recursive call to this algorithm.
+\:Return $F_B \cup F_C$.
+\algout The minimum spanning tree of~$G$.
+\endalgo
+
+Correctness of this algorithm immediately follows from the Partitioning theorem (\ref{partthm})
+and from the proofs of the respective algorithms used as subroutines. As for time complexity:
+
+\lemma\id{optlemma}%
+The time complexity $T(m,n)$ of the Optimal algorithm satisfies the following recurrence:
+$$
+T(m,n) \le \sum_i c_1 D(C_i) + T(m/2, n/4) + c_2 m,
+$$
+where~$c_1$ and~$c_2$ are some positive constants and $D$~is the decision tree complexity
+from the previous section.
+
+It turns out that the recurrence is satisfied by the decision tree complexity function
+$D(m,n)$ itself, so we can prove the following theorem by induction:
+
+\thm
+The time complexity of the Optimal algorithm is $\Theta(D(m,n))$.
+
+\paran{Complexity of MST}%
+As we have already noted, the exact decision tree complexity $D(m,n)$ of the MST problem
+is still open and so therefore is the time complexity of the optimal algorithm. However,
+every time we come up with another comparison-based algorithm, we can use its complexity
+(or more specifically the number of comparisons it performs, which can be even lower)
+as an~upper bound on the optimal algorithm.
+The best explicit comparison-based algorithm known to date has been discovered by Chazelle
+\cite{chazelle:ackermann} and independently by Pettie \cite{pettie:ackermann}. It achieves complexity $\O(m\timesalpha(m,n))$.
+Using any of these results, we can prove an~Ackermannian upper bound on the
+optimal algorithm:
+
+\thm
+The time complexity of the Optimal algorithm is $\O(m\alpha(m,n))$.
+
+%--------------------------------------------------------------------------------
+