BUGS: Little ones to fix

[saga.git] / epilog.tex

diff --git a/epilog.tex b/epilog.tex
index 45111d7b044ba5dc0e64b92fafd39eaa611e7dd2..d4dfd1887e38337e6d4a2dd547ff9ec841dffcea 100644 (file)
--- a/epilog.tex
+++ b/epilog.tex
@@ -8,14 +8,13 @@ We have seen the many facets of the minimum spanning tree problem. It has
 turned out that while the major question of the existence of a~linear-time
 MST algorithm is still open, backing off a~little bit in an~almost arbitrary
 direction leads to a~linear solution. This includes classes of graphs with edge
-density at least $\lambda_k(n)$ for an~arbitrary fixed~$k$ (Corollary \ref{lambdacor}),
-minor-closed classes (Theorem \ref{mstmcc}), and graphs whose edge weights are
-integers (Theorem \ref{intmst}). Using randomness also helps (Theorem \ref{kktavg}),
-as does having the edges pre-sorted (Example \ref{sortededges}).
+density at least $\lambda_k(n)$ for an~arbitrary fixed~$k$,
+minor-closed classes, and graphs whose edge weights are
+integers. Using randomness also helps, as does having the edges pre-sorted.
 
 If we do not know anything about the structure of the graph and we are only allowed
-to compare the edge weights, we can use the Pettie's MST algorithm (Theorem
-\ref{optthm}). Its time complexity is guaranteed to be asymptotically optimal,
+to compare the edge weights, we can use the Pettie's MST algorithm.
+Its time complexity is guaranteed to be asymptotically optimal,
 but we do not know what it really is --- the best what we have is
 an~$\O(m\timesalpha(m,n))$ upper bound and the trivial $\Omega(m)$ lower bound.
 
@@ -28,7 +27,7 @@ to study the complexity of MST decision trees. However, aside from the propertie
 mentioned in Section \ref{dtsect}, not much is known about these trees so far.
 
 As for the dynamic algorithms, we have an~algorithm which maintains the minimum
-spanning forest within poly-logarithmic time per operation (Corollary \ref{dynmsfcorr}).
+spanning forest within poly-logarithmic time per operation.
 The optimum complexity is once again undecided --- the known lower bounds are very far
 from the upper ones.
 The known algorithms run on the Pointer machine and we do not know if using a~stronger
@@ -38,9 +37,11 @@ For the ranking problems, the situation is completely different. We have shown
 linear-time algorithms for three important problems of this kind. The techniques,
 which we have used, seem to be applicable to other ranking problems. On the other
 hand, ranking of general restricted permutations has turned out to balance on the
-verge of $\#P$-completeness (Theorem \ref{pcomplete}). All our algorithms run
+verge of $\#{\rm P}$-completeness. All our algorithms run
 on the RAM model, which seems to be the only sensible choice for problems of
-inherently arithmetic nature.
+inherently arithmetic nature. While the unit-cost assumption on arithmetic operations
+is not universally accepted, our results imply that the complexity of our algorithm
+is dominated by the necessary arithmetics.
 
 Aside from the concrete problems we have solved, we have also built several algorithmic
 techniques of general interest: the unification procedures using pointer-based