Expected Running Time Research Articles

Optimising Gröbner Bases on Bivium

Bivium is a reduced version of the stream cipher Trivium. In this paper we investigate how fast a key recovery attack on Bivium using Grobner bases is. First we explain the attack scenario and the cryptographic background. Then we identify the factors that have impact on the computation time and show how to optimise them. As a side effect these experiments benchmark several Grobner basis implementations. The optimised version of the Grobner attack has an expected running time of 239.12 s, beating the attack time of our previous SAT solver attack by a factor of more than 330. Furthermore this approach is faster than an attack based on BDDs, an exhaustive key search, a generic time-memory trade-off attack and a guess-and-determine strategy.

EDIT DISTANCE WITH COMBINATIONS AND SPLITS AND ITS APPLICATIONS IN OCR NAME MATCHING

Approximate pattern matching has a wide range of applications and, depending on the type of approximation, there exist numerous algorithms for solving it. In this article we focus on texts which originate from OCRed documents, whose errors quite often have a particular form and are far from being random errors. We introduce a new variant of the edit distance metric, where apart from the traditional edit operations, two new operations are supported. The combination operation allows two or more symbols from a string x to be interpreted as a single symbol and then "matched" (or aligned) against a single symbol of a second string y. Its dual is the operation of a split, where a single symbol from x is broken down into a sequence of two or more other symbols, that can then be matched against an equal number of symbols from y. Our algorithm requires O(L) time for preprocessing, and O(mnk) time for computing the edit distance, where L is the total length of all the valid combinations/splits, m and n are the lengths of the two strings under comparison and k is an upper bound on the number of valid splits for any single symbol. The expected running time is O(mn).

Multi-modal Motion Planning in Non-expansive Spaces

Motion planning problems encountered in manipulation and legged locomotion have a distinctive multi-modal structure, where the space of feasible configurations consists of intersecting submanifolds, often of different dimensionalities. Such a feasible space does not possess expansiveness, a property that characterizes whether planning queries can be solved efficiently with traditional probabilistic roadmap (PRM) planners. In this paper we present a new PRM-based multi-modal planning algorithm for problems where the number of intersecting manifolds is finite. We also analyze the completeness properties of this algorithm. More specifically, we show that the algorithm converges quickly when each submanifold is individually expansive and establish a bound on the expected running time in that case. We also present an incremental variant of the algorithm that has the same convergence properties, but works better for problems with a large number of submanifolds by considering subsets of submanifolds likely to contain a solution path. These algorithms are demonstrated in geometric examples and in a legged locomotion planner.

An expected polynomial time algorithm for coloring 2-colorable 3-graphs

Abstract We present an algorithm that colors a random 2-colorable 3-uniform hypergraph optimally in expected running time O ( n 5 log 2 n ) .

Optimal resilient sorting and searching in the presence of memory faults

We investigate the problem of reliable computation in the presence of faults that may arbitrarily corrupt memory locations. In this framework, we consider the problems of sorting and searching in optimal time while tolerating the largest possible number of memory faults. In particular, we design an O ( n log n ) time sorting algorithm that can optimally tolerate up to O ( n log n ) memory faults. In the special case of integer sorting, we present an algorithm with linear expected running time that can tolerate O ( n ) faults. We also present a randomized searching algorithm that can optimally tolerate up to O ( log n ) memory faults in O ( log n ) expected time, and an almost optimal deterministic searching algorithm that can tolerate O ( ( log n ) 1 − ϵ ) faults, for any small positive constant ϵ , in O ( log n ) worst-case time. All these results improve over previous bounds.

New Approximation Algorithms for Minimum Cycle Bases of Graphs

We consider the problem of computing an approximate minimum cycle basis of an undirected non-negative edge-weighted graph G with m edges and n vertices; the extension to directed graphs is also discussed. In this problem, a {0,1} incidence vector is associated with each cycle and the vector space over $\mathbb{F}_{2}$ generated by these vectors is the cycle space of G. A set of cycles is called a cycle basis of G if it forms a basis for its cycle space. A cycle basis where the sum of the weights of the cycles is minimum is called a minimum cycle basis of G. Cycle bases of low weight are useful in a number of contexts, e.g. the analysis of electrical networks, structural engineering, chemistry, and surface reconstruction. Although in most such applications any cycle basis can be used, a low weight cycle basis often translates to better performance and/or numerical stability. Despite the fact that the problem can be solved exactly in polynomial time, we design approximation algorithms since the performance of the exact algorithms may be too expensive for some practical applications. We present two new algorithms to compute an approximate minimum cycle basis. For any integer k≥1, we give (2k−1)-approximation algorithms with expected running time O(kmn 1+2/k +mn (1+1/k)(ω−1)) and deterministic running time O(n 3+2/k ), respectively. Here ω is the best exponent of matrix multiplication. It is presently known that ω<2.376. Both algorithms are o(m ω ) for dense graphs. This is the first time that any algorithm which computes sparse cycle bases with a guarantee drops below the Θ(m ω ) bound. We also present a 2-approximation algorithm with expected running time $O(m^{\omega}\sqrt{n\log n})$ , a linear time 2-approximation algorithm for planar graphs and an O(n 3) time 2.42-approximation algorithm for the complete Euclidean graph in the plane.

Computing an approximation of the 1-center problem on weighted terrain surfaces

In this article, we discuss the problem of determining a meeting point of a set of scattered robots R = { r 1 , r 2 ,…, r s } in a weighted terrain P, which has n &gt; s triangular faces. Our algorithmic approach is to produce a discretization of P by producing a graph G = { V G , E G }, which lies on the surface of P. For a chosen vertex p′ ∈ V G , we define ‖Π( r i , p′ )‖ as the minimum weight cost of traveling from r i to p′ . We show that min p′ ∈ V G {max 1≤ i ≤ s {‖Π( r i , p′ )‖}} ≤ min p *∈P {max 1≤ i ≤ s {‖Π( r i , p *)‖}} + 2 W | L |, where L is the longest edge of P, W is the maximum cost weight of a face of P, and p * is the optimal solution. Our algorithm requires O ( snm log( snm ) + snm 2 ) time to run, where m = n in the Euclidean metric and m = n 2 in the weighted metric. However, we show, through experimentation, that only a constant value of m is required (e.g., m = 8) in order to produce very accurate solutions (&lt; 1% error). Hence, for typical terrain data, the expected running time of our algorithm is O ( sn log( sn )). Also, as part of our experiments, we show that by using geometrical subsets (i.e., 2D/3D convex hulls, 2D/3D bounding boxes, and random selection) of the robots we can improve the running time for finding p′ , with minimal or no additional accuracy error when comparing p′ to p *.

Sparse Algebraic Equations over Finite Fields

A system of algebraic equations over a finite field is called sparse if each equation depends on a low number of variables. Efficiently finding solutions to the system is an underlying hard problem in cryptanalysis of modern ciphers. In this paper the deterministic Agreeing-Gluing algorithm introduced earlier by Raddum and Semaev for solving such equations is studied. Its expected running time on uniformly random instances of the problem is rigorously estimated. The estimate is at present the best theoretical bound on the complexity of solving average instances of the problem. In sparse Boolean equations we observe an exciting difference with the worst-case complexity provided by SAT solving methods.

Beyond Hirsch Conjecture: Walks on Random Polytopes and Smoothed Complexity of the Simplex Method

The smoothed analysis of algorithms is concerned with the expected running time of an algorithm under slight random perturbations of arbitrary inputs. Spielman and Teng proved that the shadow vertex simplex method has polynomial smoothed complexity. On a slight random perturbation of an arbitrary linear program, the simplex method finds the solution after a walk on polytope(s) with expected length polynomial in the number of constraints n, the number of variables d, and the inverse standard deviation of the perturbation $1/\sigma$. We show that the length of walk in the simplex method is actually polylogarithmic in the number of constraints n. Spielman–Teng's bound on the walk was $O^*(n^{86}d^{55}\sigma^{-30})$, up to logarithmic factors. We improve this to $O(\log^7n(d^9+d^3\sigma^{-4}))$. This shows that the tight Hirsch conjecture $n-d$ on the length of walk on polytopes is not a limitation for the smoothed linear programming. Random perturbations create short paths between vertices. We propose a randomized Phase-I for solving arbitrary linear programs, which is of independent interest. Instead of finding a vertex of a feasible set, we add a vertex at random to the feasible set. This does not affect the solution of the linear program with constant probability. So, in expectation it takes a constant number of independent trials until a correct solution is found. This overcomes one of the major difficulties of smoothed analysis of the simplex method—one can now statistically decouple the walk from the smoothed linear program. This yields a much better reduction of the smoothed complexity to a geometric quantity—the size of planar sections of random polytopes. We also improve upon the known estimates for that size, showing that it is polylogarithmic in the number of vertices.

Evolutionary Algorithms and Matroid Optimization Problems

We analyze the performance of evolutionary algorithms on various matroid optimization problems that encompass a vast number of efficiently solvable as well as NP-hard combinatorial optimization problems (including many well-known examples such as minimum spanning tree and maximum bipartite matching). We obtain very promising bounds on the expected running time and quality of the computed solution. Our results establish a better theoretical understanding of why randomized search heuristics yield empirically good results for many real-world optimization problems.

A meeting scheduling problem respecting time and space

We consider the problem of determining suitable meeting times and locations for a group of participants wishing to schedule a new meeting subject to already scheduled meetings possibly held at a number of different locations. Each participant must be able to reach the new meeting location, attend for the entire duration, and reach the next meeting location on time. In particular, we give two solutions to the problem instance where each participant has two scheduled meetings separated by a free time interval. We present an O(n logn) algorithm for n participants obtained by purely geometrical arguments. Our second approach uses the concept of LP-type problems and leads to a randomized algorithm with expected running time O(n). We also consider a graph-based model where participants belong to different groups and can travel along the edges of a graph. For the meeting, only one member out of each group is required. The resulting problem can be solved using furthest color Voronoi diagrams on graphs.

Perfect simulation with exponential tails on the running time

AbstractMonte Carlo algorithms typically need to generate random variates from a probability distribution described by an unnormalized density or probability mass function. Perfect simulation algorithms generate random variates exactly from these distributions, but have a running time T that is itself an unbounded random variable. This article shows that commonly used protocols for creating perfect simulation algorithms, such as Coupling From the Past can be used in such a fashion that the running time is unlikely to be very much larger than the expected running time. © 2008 Wiley Periodicals, Inc. Random Struct. Alg., 2008

Randomized minimum spanning tree algorithms using exponentially fewer random bits

For many fundamental problems there exist randomized algorithms that are asymptotically optimal and are superior to the best-known deterministic algorithm. Among these are the minimum spanning tree (MST) problem, the MST sensitivity analysis problem, the parallel connected components and parallel minimum spanning tree problems, and the local sorting and set maxima problems. (For the first two problems there are provably optimal deterministic algorithms with unknown, and possibly superlinear, running times.) One downside of the randomized methods for solving these problems is that they use a number of random bits linear in the size of input. In this article we develop some general methods for reducing exponentially the consumption of random bits in comparison-based algorithms. In some cases we are able to reduce the number of random bits from linear to nearly constant, without affecting the expected running time. Most of our results are obtained by adjusting or reorganizing existing randomized algorithms to work well with a pairwise or O (1)-wise independent sampler. The prominent exception, and the main focus of this article, is a linear-time randomized minimum spanning tree algorithm that is not derived from the well-known Karger-Klein-Tarjan algorithm. In many ways it resembles more closely the deterministic minimum spanning tree algorithms based on soft heaps. Further, using our algorithm as a guide, we present a unified view of the existing “nongreedy” minimum spanning tree algorithms. Concepts from the Karger-Klein-Tarjan algorithm, such as F -lightness, MST verification, and sampled graphs, are related to the concepts of edge corruption, subgraph contractibility, and soft heaps, which are the basis of the deterministic MST algorithms of Chazelle and Pettie-Ramachandran.

Provably Fast Training Algorithms for Support Vector Machines

Support Vector Machines are a family of algorithms for the analysis of data based on convex Quadratic Programming. We derive randomized algorithms for training SVMs, based on a variation of Random Sampling Techniques; these have been successfully used for similar problems. We formally prove an upper bound on the expected running time which is quasilinear with respect to the number of data points and polynomial with respect to the other parameters, i.e., the number of attributes and the inverse of a chosen soft margin parameter. [This is the combined journal version of the conference papers (Balcazar, J.L. et al. in Proceedings of 12th International Conference on Algorithmic Learning Theory (ALT’01), pp. 119–134, [2001]; Balcazar, J.L. et al. in Proceedings of First IEEE International Conference on Data Mining (ICDM’01), pp. 43–50, [2001]; and Balcazar, J.L. et al. in Proceedings of SIAM Workshop in Discrete Mathematics and Data Mining, pp. 19–29, [2002]).]

Compressed indexing and local alignment of DNA

Recent experimental studies on compressed indexes (BWT, CSA, FM-index) have confirmed their practicality for indexing very long strings such as the human genome in the main memory. For example, a BWT index for the human genome (with about 3 billion characters) occupies just around 1 G bytes. However, these indexes are designed for exact pattern matching, which is too stringent for biological applications. The demand is often on finding local alignments (pairs of similar substrings with gaps allowed). Without indexing, one can use dynamic programming to find all the local alignments between a text T and a pattern P in O(|T||P|) time, but this would be too slow when the text is of genome scale (e.g. aligning a gene with the human genome would take tens to hundreds of hours). In practice, biologists use heuristic-based software such as BLAST, which is very efficient but does not guarantee to find all local alignments. In this article, we show how to build a software called BWT-SW that exploits a BWT index of a text T to speed up the dynamic programming for finding all local alignments. Experiments reveal that BWT-SW is very efficient (e.g. aligning a pattern of length 3 000 with the human genome takes less than a minute). We have also analyzed BWT-SW mathematically for a simpler similarity model (with gaps disallowed), and we show that the expected running time is O(/T/(0.628)/P/) for random strings. As far as we know, BWT-SW is the first practical tool that can find all local alignments. Yet BWT-SW is not meant to be a replacement of BLAST, as BLAST is still several times faster than BWT-SW for long patterns and BLAST is indeed accurate enough in most cases (we have used BWT-SW to check against the accuracy of BLAST and found that only rarely BLAST would miss some significant alignments). www.cs.hku.hk/~ckwong3/bwtsw twlam@cs.hku.hk.

An algorithm with linear expected running time for string editing with substitutions and substring reversals

The edit distance between given two strings X and Y is the minimum number of edit operations that transform X into Y without performing multiple operations that involve the same position. Ordinarily, string editing is based on character insert, delete, and substitute operations. Motivated from the facts that substring reversals are observed in genomic sequences, and it is not always possible to transform a given sequence X into a given sequence Y by reversals alone (e.g., X is all 0's, and Y is all 1's), Muthukrishnan and Sahinalp [S. Muthukrishnan, S.C. Sahinalp, Approximate nearest neighbors and sequence comparison with block operations, in: Proc. ACM Symposium on Theory of Computing (STOC), 2000, pp. 416–424; S. Muthukrishnan, S.C. Sahinalp, An improved algorithm for sequence comparison with block reversals, Theoretical Computer Science 321 (1) (2004) 95–101] considered a “simple” well-defined edit distance model in which the edit operations are: replace a character, and reverse and replace a substring. A substring of X can only be reversed if the reversal results in a match in the same position in Y. The cost of each character replacement and substring reversal is 1. The distance in this case is defined only when | X | = | Y | = n . There is an algorithm for computing the distance in this model with worst-case time complexity O ( n log 2 n ) [S. Muthukrishnan, S.C. Sahinalp, An improved algorithm for sequence comparison with block reversals, Theoretical Computer Science 321 (1) (2004) 95–101]. We present a dynamic programming algorithm with worst-case time complexity O ( n 2 ) but its expected running-time is O ( n ) . In our dynamic programming solution the weights of edit operations can vary for different substitutions, and the costs of reversals can be a function of the reversal-length.

Maximum overlap and minimum convex hull of two convex polyhedra under translations

Given two convex polyhedra P and Q in three-dimensional space, we consider two related problems of shape matching: (1) finding a translation t 1 ∈ R 3 of Q that maximizes the volume of their overlap P ∩ ( Q + t 1 ) , and (2) finding a translation t 2 ∈ R 3 that minimizes the volume of the convex hull of P ∪ ( Q + t 2 ) . For the maximum overlap problem, we observe that the dth root of the objective function is concave and present an algorithm that computes the optimal translation in expected time O ( n 3 log 4 n ) . This method generalizes to higher dimensions d > 3 with expected running time O ( n d + 1 − 3 d ( log n ) d + 1 ) . For the minimum convex hull problem, we show that the objective function is convex. The same method used for the maximum overlap problem can be applied to this problem and the optimal translation can be computed in the same time bound.

Efficient CM-constructions of elliptic curves over finite fields

We present an algorithm that, on input of an integer $N\ge 1$ together with its prime factorization, constructs a finite field $\mathbf {F}$ and an elliptic curve $E$ over $\mathbf {F}$ for which $E({\mathbf {F} })$ has order $N$. Although it is unproved that this can be done for all $N$, a heuristic analysis shows that the algorithm has an expected run time that is polynomial in $2^{\omega (N)}\log N$, where $\omega (N)$ is the number of distinct prime factors of $N$. In the cryptographically relevant case where $N$ is prime, an expected run time $O((\log N)^{4+\varepsilon })$ can be achieved. We illustrate the efficiency of the algorithm by constructing elliptic curves with point groups of order $N=10^{2004}$ and $N=\text {nextprime}(10^{2004})=10^{2004}+4863$.

Estimating the distance to a monotone function

AbstractIn standard property testing, the task is to distinguish between objects that have a property 𝒫 and those that are ε‐far from 𝒫, for some ε &gt; 0. In this setting, it is perfectly acceptable for the tester to provide a negative answer for every input object that does not satisfy 𝒫. This implies that property testing in and of itself cannot be expected to yield any information whatsoever about the distance from the object to the property. We address this problem in this paper, restricting our attention to monotonicity testing. A function f : {1,…,n} ↦ R is at distance εf from being monotone if it can (and must) be modified at εfn places to become monotone. For any fixed δ &gt; 0, we compute, with probability at least 2/3, an interval [(1/2 − δ)ε,ε] that encloses εf. The running time of our algorithm is O(εf−1 log log εf− 1 log n), which is optimal within a factor of loglog εf−1 and represents a substantial improvement over previous work. We give a second algorithm with an expected running time of O(εf−1 log nlog log log n). Finally, we extend our results to multivariate functions. © 2007 Wiley Periodicals, Inc. Random Struct. Alg., 2007

Computing the least quartile difference estimator in the plane

A common problem in linear regression is that largely aberrant values can strongly influence the results. The least quartile difference (LQD) regression estimator is highly robust, since it can resist up to almost 50 % largely deviant data values without becoming extremely biased. Additionally, it shows good behavior on Gaussian data—in contrast to many other robust regression methods. However, the LQD is not widely used yet due to the high computational effort needed when using common algorithms. It is shown that it is possible to compute the LQD estimator for n bivariate data points in expected running time O ( n 2 log n ) or deterministic running time O ( n 2 log 2 n ) . Additionally, two easy to implement algorithms with slightly inferior time bounds are presented. All of these algorithms are also applicable to least quantile of squares and least median of squares regression through the origin, improving the known time bounds to expected time O ( n log n ) and deterministic time O ( n log 2 n ) . The proposed algorithms improve on known results of existing LQD algorithms and hence increase the practical relevance of the LQD estimator.