Started with robust contractions.

diff --git a/adv.tex b/adv.tex
index da6d941e42d36361e6c75841b40aebf8c35e989a..6836d438587d20080a91a9480e213fa900eeaadb 100644 (file)
--- a/adv.tex
+++ b/adv.tex
@@ -407,7 +407,7 @@ we conserve the current tree and start with a~different vertex and an~empty heap
 process runs out of vertices, it has identified a~sub-forest of the MST, so we can
 contract the graph along the edges of~this forest and iterate.
 
-\algn{Iterated Jarn\'\i{}k; Fredman and Tarjan \cite{ft:fibonacci}}
+\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}

diff --git a/mst.tex b/mst.tex
index b915272b62a7ab165ff03d38805731aa41a7db00..85c8b455f20f518abd729b83618b9a760f1ef9d5 100644 (file)
--- a/mst.tex
+++ b/mst.tex
@@ -244,7 +244,7 @@ of choosing the rules in this procedure, which justifies the name meta-algorithm
 We will denote the unique minimum spanning tree of the input graph by~$T_{min}$.
 We intend to prove that this is also the output of the procedure.
 
-\lemman{Blue lemma}%
+\lemman{Blue lemma}\id{bluelemma}%
 When an edge is colored blue in any step of the procedure, it is contained in the minimum spanning tree.
 
 \proof

diff --git a/opt.tex b/opt.tex
index 7ffcac355da706f89e0b4db05e66616f54a9d7cc..95acd7e158db52852e4781c0f4c82b7d6ee8e3b1 100644 (file)
--- a/opt.tex
+++ b/opt.tex
@@ -509,6 +509,36 @@ by rebuilding the whole data structure completely after $n/2$ deletes. This
 increases the number of potentially corrupted items, but at worst twice, so it
 suffices to decrease~$\varepsilon$ twice.
 
+\section{Robust contractions}
+
+Having the soft heaps at hand, we would like to use them in a~conventional MST
+algorithm in place of a~usual heap. The most efficient specimen of a~heap-based
+algorithm we have seen so far is the Iterated Jarn\'\i{}k's algorithm (\ref{itjar}).
+It is based on a~simple, yet powerful idea: Use the Jarn\'\i{}k's algorithm with
+limited heap size, so that it stops when the tree becomes large. Grow multiple
+such trees, always starting in vertex not visited yet. All these trees lie in the
+MST, so by the Contraction lemma (\ref{contlemma}) we can contract each of them
+to a~single vertex and iterate the algorithm on the resulting graph.
+
+We can try implanting the soft heap in this algorithm (preferably in the original
+version without active edges \ref{jarnik} as we the soft heap lacks the \<Decrease>
+operation) and patching the holes by some sort of duct tape. This honest, 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 a~subset of edges. In presence
+of corrupted edges, most of the theory we have so carefully built breaks down. For example,
+the Blue lemma (\ref{bluelemma}) now holds only when we consider a~cut with no corrupted
+edges, with a~possible exception of the lightest edge of the cut. Similarly, the Red lemma
+(\ref{redlemma}) is true only if the heaviest edge on the cycle is not corrupted.
+
+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 which takes the corrupted edges into account. Before we prove this lemma,
+we will expand our awareness of subgraphs which can be contracted.
+
+\defn
+A~subgraph $C\subset G$ is \df{contractible} iff for every pair of edges $e,f\in\delta(C)$\foot{That is,
+with one endpoint in~$C$.} the subset 
+
 
 
 \endpart