Non-trivial Algorithm Research Articles

Error scaling in fault tolerant quantum computation

The threshold theorem states that quantum computations can scale robustly in the presence of certain types of noise processes (e.g., Markovian) as long as the probability of error for each physical component remains below a critical threshold. To satisfy this threshold a theoretical circuit requiring O(s) idealized noiseless gates can be implemented with O(s polylog s) gates to maintain an error rate that is constant with increasing s. In this paper, we argue that maintaining a fixed error rate is necessary but not sufficient to preserve complexity results obtained under an assumption of noiseless gates. Specifically, we show that nontrivial quantum algorithms exhibit nonlinear sensitivity to any circuit error and that this sensitivity affects algorithmic complexity. The joint effects of circuit error and quantum-algorithmic iteration are examined for the case of quantum search, and more complete complexity results are derived.

The World in a Nutshell: Concise Range Queries

With the advance of wireless communication technology, it is quite common for people to view maps or get related services from the handheld devices, such as mobile phones and PDAs. Range queries, as one of the most commonly used tools, are often posed by the users to retrieve needful information from a spatial database. However, due to the limits of communication bandwidth and hardware power of handheld devices, displaying all the results of a range query on a handheld device is neither communication-efficient nor informative to the users. This is simply because that there are often too many results returned from a range query. In view of this problem, we present a novel idea that a concise representation of a specified size for the range query results, while incurring minimal information loss, shall be computed and returned to the user. Such a concise range query not only reduces communication costs, but also offers better usability to the users, providing an opportunity for interactive exploration. The usefulness of the concise range queries is confirmed by comparing it with other possible alternatives, such as sampling and clustering. Unfortunately, we prove that finding the optimal representation with minimum information loss is an NP-hard problem. Therefore, we propose several effective and nontrivial algorithms to find a good approximate result. Extensive experiments on real-world data have demonstrated the effectiveness and efficiency of the proposed techniques.

The complexity of causality and responsibility for query answers and non-answers

An answer to a query has a well-defined lineage expression (alternatively called how-provenance) that explains how the answer was derived. Recent work has also shown how to compute the lineage of a non-answer to a query. However, the cause of an answer or non-answer is a more subtle notion and consists, in general, of only a fragment of the lineage. In this paper, we adapt Halpern, Pearl, and Chockler's recent definitions of causality and responsibility to define the causes of answers and non-answers to queries, and their degree of responsibility . Responsibility captures the notion of degree of causality and serves to rank potentially many causes by their relative contributions to the effect. Then, we study the complexity of computing causes and responsibilities for conjunctive queries. It is known that computing causes is NP-complete in general. Our first main result shows that all causes to conjunctive queries can be computed by a relational query which may involve negation. Thus, causality can be computed in PTIME, and very efficiently so. Next, we study computing responsibility. Here, we prove that the complexity depends on the conjunctive query and demonstrate a dichotomy between PTIME and NP-complete cases. For the PTIME cases, we give a non-trivial algorithm, consisting of a reduction to the max-flow computation problem. Finally, we prove that, even when it is in PTIME, responsibility is complete for LOGSPACE, implying that, unlike causality, it cannot be computed by a relational query.

Perfect matchings via uniform sampling in regular bipartite graphs

In this article we further investigate the well-studied problem of finding a perfect matching in a regular bipartite graph. The first nontrivial algorithm, with running time O ( mn ), dates back to König's work in 1916 (here m = nd is the number of edges in the graph, 2 n is the number of vertices, and d is the degree of each node). The currently most efficient algorithm takes time O(m) , and is due to Cole et al. [2001]. We improve this running time to O (min{ m , n 2.5 ln n / d }); this minimum can never be larger than O ( n 1.75 √ln n ). We obtain this improvement by proving a uniform sampling theorem: if we sample each edge in a d -regular bipartite graph independently with a probability p = O ( n ln n / d 2 ) then the resulting graph has a perfect matching with high probability. The proof involves a decomposition of the graph into pieces which are guaranteed to have many perfect matchings but do not have any small cuts. We then establish a correspondence between potential witnesses to nonexistence of a matching (after sampling) in any piece and cuts of comparable size in that same piece. Karger's sampling theorem [1994a, 1994b] for preserving cuts in a graph can now be adapted to prove our uniform sampling theorem for preserving perfect matchings. Using the O ( m √ n ) algorithm (due to Hopcroft and Karp [1973]) for finding maximum matchings in bipartite graphs on the sampled graph then yields the stated running time. We also provide an infinite family of instances to show that our uniform sampling result is tight up to polylogarithmic factors (in fact, up to ln 2 n ).

Robinson-Foulds supertrees.

BackgroundSupertree methods synthesize collections of small phylogenetic trees with incomplete taxon overlap into comprehensive trees, or supertrees, that include all taxa found in the input trees. Supertree methods based on the well established Robinson-Foulds (RF) distance have the potential to build supertrees that retain much information from the input trees. Specifically, the RF supertree problem seeks a binary supertree that minimizes the sum of the RF distances from the supertree to the input trees. Thus, an RF supertree is a supertree that is consistent with the largest number of clusters (or clades) from the input trees.ResultsWe introduce efficient, local search based, hill-climbing heuristics for the intrinsically hard RF supertree problem on rooted trees. These heuristics use novel non-trivial algorithms for the SPR and TBR local search problems which improve on the time complexity of the best known (naïve) solutions by a factor of Θ(n) and Θ(n2) respectively (where n is the number of taxa, or leaves, in the supertree). We use an implementation of our new algorithms to examine the performance of the RF supertree method and compare it to matrix representation with parsimony (MRP) and the triplet supertree method using four supertree data sets. Not only did our RF heuristic provide fast estimates of RF supertrees in all data sets, but the RF supertrees also retained more of the information from the input trees (based on the RF distance) than the other supertree methods.ConclusionsOur heuristics for the RF supertree problem, based on our new local search algorithms, make it possible for the first time to estimate large supertrees by directly optimizing the RF distance from rooted input trees to the supertrees. This provides a new and fast method to build accurate supertrees. RF supertrees may also be useful for estimating majority-rule(-) supertrees, which are a generalization of majority-rule consensus trees.

On implementing recognizable transductions

Recognizable transductions constitute a proper subclass of rational transductions, characterized by the well-known Mezei's Theorem. We propose a family of transducers which reflect accurately this characterization, and we study their properties and their algorithmic aspects. We base our construct on the observation that there is a connection between recognizable transductions and languages consisting of edit strings. More specifically, we define a saturated transducer to be a transducer with the property that accepts all possible edit strings corresponding to each accepted pair of words, when viewed as an automaton over the edit alphabet. We revisit the theory behind recognizable transductions from the point of view of saturated transducers, and we give constructive proofs as well as descriptional complexities for their closure properties. In particular, we give a novel and rather non-trivial algorithm for constructing a saturated transducer for the concatenation of two saturated transductions. Finally, we discuss the natural role of these objects in edit distance problems. Perhaps the relevance of this work lies more in its point of view and initiative rather than in any particular result.

Proving that non-blocking algorithms don't block

A concurrent data-structure implementation is considered non-blocking if it meets one of three following liveness criteria: wait-freedom, lock-freedom, or obstruction-freedom. Developers of non-blocking algorithms aim to meet these criteria. However, to date their proofs for non-trivial algorithms have been only manual pencil-and-paper semi-formal proofs. This paper proposes the first fully automatic tool that allows developers to ensure that their algorithms are indeed non-blocking. Our tool uses rely-guarantee reasoning while overcoming the technical challenge of sound reasoning in the presence of interdependent liveness properties.

On Agnostic Learning of Parities, Monomials, and Halfspaces

We study the learnability of several fundamental concept classes in the agnostic learning framework of [D. Haussler, Inform. and Comput., 100 (1992), pp. 78-150] and [M. Kearns, R. Schapire, and L. Sellie, Machine Learning, 17 (1994), pp. 115-141]. We show that under the uniform distribution, agnostically learning parities reduce to learning parities with random classification noise, commonly referred to as the noisy parity problem. Together with the parity learning algorithm of [A. Blum, A. Kalai, and H. Wasserman, J. ACM, 50 (2003), pp. 506-519], this gives the first nontrivial algorithm for agnostic learning of parities. We use similar techniques to reduce learning of two other fundamental concept classes under the uniform distribution to learning of noisy parities. Namely, we show that learning of disjunctive normal form (DNF) expressions reduces to learning noisy parities of just logarithmic number of variables, and learning of $k$-juntas reduces to learning noisy parities of $k$ variables. We give essentially optimal hardness results for agnostic learning of monomials over $\{0,1\}^n$ and halfspaces over $\mathbb{Q}^n$. We show that for any constant $\epsilon$ finding a monomial (halfspace) that agrees with an unknown function on $1/2+\epsilon$ fraction of the examples is NP-hard even when there exists a monomial (halfspace) that agrees with the unknown function on $1-\epsilon$ fraction of the examples. This resolves an open question due to Blum and significantly improves on a number of previous hardness results for these problems. We extend these results to $\epsilon=2^{-\log^{1-\lambda}n}$ ($\epsilon=2^{-\sqrt{\log n}}$ in the case of halfspaces) for any constant $\lambda>0$ under stronger complexity assumptions.

Triplet supertree heuristics for the tree of life

BackgroundThere is much interest in developing fast and accurate supertree methods to infer the tree of life. Supertree methods combine smaller input trees with overlapping sets of taxa to make a comprehensive phylogenetic tree that contains all of the taxa in the input trees. The intrinsically hard triplet supertree problem takes a collection of input species trees and seeks a species tree (supertree) that maximizes the number of triplet subtrees that it shares with the input trees. However, the utility of this supertree problem has been limited by a lack of efficient and effective heuristics.ResultsWe introduce fast hill-climbing heuristics for the triplet supertree problem that perform a step-wise search of the tree space, where each step is guided by an exact solution to an instance of a local search problem. To realize time efficient heuristics we designed the first nontrivial algorithms for two standard search problems, which greatly improve on the time complexity to the best known (naïve) solutions by a factor of n and n2 (the number of taxa in the supertree). These algorithms enable large-scale supertree analyses based on the triplet supertree problem that were previously not possible. We implemented hill-climbing heuristics that are based on our new algorithms, and in analyses of two published supertree data sets, we demonstrate that our new heuristics outperform other standard supertree methods in maximizing the number of triplets shared with the input trees.ConclusionWith our new heuristics, the triplet supertree problem is now computationally more tractable for large-scale supertree analyses, and it provides a potentially more accurate alternative to existing supertree methods.

Higher-Order Separation Logic in Isabelle/HOLCF

We formalize higher-order separation logic for a first-order imperative language with procedures and local variables in Isabelle/HOLCF. The assertion language is modeled in such a way that one may use any theory defined in Isabelle/HOLCF to construct assertions, e.g., primitive recursion, least or greatest fixed points etc. The higher-order logic ensures that we can show non-trivial algorithms correct without having to extend the semantics of the language as was done previously in verifications based on first-order separation logic [Birkedal, L., N.T. Smith and J.C. Reynolds, Local reasoning about a copying garbage collector, in: Proceedings of the 31st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (2004), pp. 220–231; Yang, H., An example of local reasoning in BI pointer logic: the Schorr-Waite graph marking algorithm (2000)]. We provide non-trivial examples to support this claim and to show how the higher-order logic enables natural assertions in specifications. To support abstract reasoning we have implemented rules for representation hiding and data abstraction as seen in [Biering, B., L. Birkedal and N. Torp-Smith, BI-hyperdoctrines, higher-order separation logic, and abstraction, ACM Trans. Program. Lang. Syst. 29 (2007)].The logic is represented as lemmas for reasoning about the denotational semantics of the programming language. This follows the definitional approach common in HOL theorem provers, i.e., the soundness of our model only relies on the soundness of Isabelle/HOL [Gordon, M., Introduction to the HOL system, in: HOL Theorem Proving System and Its Applications, 1991., International Workshop on the, 1991, pp. 2–3].We use our formalization to give a formally verified proof of Cheney's copying garbage collector [Cheney, C.J., A nonrecursive list compacting algorithm, Commun. ACM 13 (1970), pp. 677–678] using a tagged representation of objects. The proof generalizes the results in [Birkedal, L., N.T. Smith and J.C. Reynolds, Local reasoning about a copying garbage collector, in: Proceedings of the 31st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (2004), pp. 220–231]. The proof uses an encoding of the separation logic formula this(h) to capture the heap from before the garbage collection and thus shows another novel use of higher-order separation logic.

Approximate k-Steiner Forests via the Lagrangian Relaxation Technique with Internal Preprocessing

An instance of the k -Steiner forest problem consists of an undirected graph G=(V,E), the edges of which are associated with non-negative costs, and a collection $\mathcal{D}=\{(s_{1},t_{1}),\ldots,(s_{d},t_{d})\}$of distinct pairs of vertices, interchangeably referred to as demands. We say that a forest ℱ⊆G connects a demand (s i ,t i ) when it contains an s i -t i path. Given a profit k i for each demand (s i ,t i ) and a requirement parameter k, the goal is to find a minimum cost forest that connects a subset of demands whose combined profit is at least k. This problem has recently been studied by Hajiaghayi and Jain (SODA ’06), whose main contribution in this context was to relate the inapproximability of k-Steiner forest to that of the dense k -subgraph problem. However, Hajiaghayi and Jain did not provide any algorithmic result for the respective settings, and posed this objective as an important direction for future research. In this paper, we present the first non-trivial approximation algorithm for the k-Steiner forest problem, which is based on a novel extension of the Lagrangian relaxation technique. Specifically, our algorithm constructs a feasible forest whose cost is within a factor of $O(\min \{n^{2/3},\sqrt{d}\}\cdot \log d)$of optimal, where n is the number of vertices in the input graph and d is the number of demands. We believe that the approach illustrated in the current writing is of independent interest, and may be applicable in other settings as well.

An Efficient Packet Scheduling Algorithm With Deadline Guarantees for Input-Queued Switches

Input-queued (IQ) switches overcome the scalability problem suffered by output-queued switches. In order to provide differential quality of services (QoS), we need to efficiently schedule a set of incoming packets so that every packet can be transferred to its destined output port before its deadline. If no such a schedule exists, we wish to find one that allows a maximum number of packets to meet their deadlines. Recently, this problem has been proved to be NP-complete if three or more distinct deadlines (classes) are present in the set. In this paper, we propose a novel algorithm named Flow-based Iterative Packet Scheduling (FIPS) for this scheduling problem. A key component in FIPS is a non-trivial algorithm that solves the problem for the case where two classes are present in the packet set. By repeatedly applying the algorithm for two classes, we solve the general case of an arbitrary number of classes more efficiently. Applying FIPS to a frame-based model effectively achieves differential QoS provision in IQ switches. Using simulations, we have compared FIPS performance with five well-known existing heuristic algorithms including Earliest-Deadline-First (EDF), Minimum-Laxity-First (MLF) and their variants. The simulation results demonstrate that our new algorithm solves the deadline guaranteed packet scheduling problem with a much higher success rate and a much lower packet drop ratio than all other algorithms.

Formal Correctness of a Quadratic Unification Algorithm

We present a case study using ACL2 to verify a nontrivial algorithm that uses efficient data structures. The algorithm receives as input two first-order terms, and it returns a most general unifier of these terms if they are unifiable, failure otherwise. The verified implementation stores terms as directed acyclic graphs by means of a pointer structure. Its time complexity is $O(n^2)$ and its space complexity $O(n)$ , and it can be executed in ACL2 at a speed comparable to a similar C implementation. We report the main issues encountered to achieve this formally verified implementation.

Finding all equilibria in games of strategic complements

I present a simple and fast algorithm that finds all the pure-strategy Nash equilibria in games with strategic complementarities. This is the first non-trivial algorithm for finding all pure-strategy Nash equilibria.

Computing obnoxious 1-corner polygonal chains

We consider an obnoxious facility location problem in which the facility is a trajectory consisting of a bounded length polygonal chain of two edges having extremes anchored at two given points. In other words, given a set S of points in the plane and a positive value l 0 , we want to compute an anchored 1-corner polygonal chain having length at most l 0 such that the minimum distance to the points in S is maximized. We present non-trivial algorithms based on geometric properties of each possible configuration providing a solution. More specifically, we give an O ( n log n ) -time algorithm for finding a 1-corner obnoxious polygonal chain whose length is exactly l 0 , and an O ( n 2 ) -time algorithm when the length of the optimal chain is at most the given bound l 0 .

Knowledge State Algorithms and the 2-Server Problem

Abstract We introduce the novel concept of knowledge states. A knowledge state simply states conditional obligations of an adversary, by fixing a work function, and gives a distribution for the algorithm. When a knowledge state algorithm receives a request, it then calculates one or more “subsequent” knowledge states, together with a probability of transition to each. The algorithm then uses randomization to select one of those subsequents to be the new knowledge state. Although the formal definition of knowledge state algorithms appears, as yet, in no publication, many well-known algorithms can be viewed as knowledge state algorithms. We have used optimization techniques to construct a non-trivial knowledge state algorithm for the 2-server problem on the line with competitive ratio 71 36 ≈ 1.972 . As much as one avenue of investigation might be to further improve this result for the line, what we really envision is to use this technique to finally settle the question of whether there exists an online algorithm with competitive ratio better than 2 for general spaces – a notorious open problen in online algorithms. For progress in that direction, we consider the class of metric spaces M 2 , 4 , which consists of all metric spaces where every distance is either 1 or 2, and where the perimeter of every triangle is either 3 or 4. Using the knowledge state approach we are able to obtain the result that there exists a C-competitive randomized online algorithm for the 2-server problem in the space M 2 , 4 with C = 173 + 137 112 ≈ 1.649149106 .

Verification of non-functional programs using interpretations in type theory

We study the problem of certifying programs combining imperative and functional features within the general framework of type theory. Type theory is a powerful specification language which is naturally suited for the proof of purely functional programs. To deal with imperative programs, we propose a logical interpretation of an annotated program as a partial proof of its specification. The construction of the corresponding partial proof term is based on a static analysis of the effects of the program which excludes aliases. The missing subterms in the partial proof term are seen as proof obligations, whose actual proofs are left to the user. We show that the validity of those proof obligations implies the total correctness of the program. This work has been implemented in the Coq proof assistant. It appears as a tactic taking an annotated program as argument and generating a set of proof obligations. Several nontrivial algorithms have been certified using this tactic.

Approximate string matching on Ziv–Lempel compressed text

We present the first nontrivial algorithm for approximate pattern matching on compressed text. The format we choose is the Ziv–Lempel family. Given a text of length u compressed into length n, and a pattern of length m, we report all the R occurrences of the pattern in the text allowing up to k insertions, deletions and substitutions. On LZ78/LZW we need O( mkn+ R) time in the worst case and O( k 2 n+ mkmin( n,( mσ) k )+ R) on average where σ is the alphabet size. The experimental results show a practical speedup over the basic approach of up to 2 X for moderate m and small k. We extend the algorithms to more general compression formats and approximate matching models.

The base-matroid and inverse combinatorial optimization problems

A new matroid is introduced: this matroid is defined starting from any matroid and one of its bases, hence we call it base-matroid. Besides some properties of the base-matroid, a non-trivial algorithm for the solution of the related matroid optimization problem is presented. The new matroid has application in the field of inverse combinatorial optimization problems. We discuss in detail the LP formulation of the inverse matroid optimization problem and we propose an efficient algorithm for computing its primal and dual solutions.

Finding All Equilibria

I present a simple and fast algorithm that finds all the pure-strategy Nash equilibria in games with strategic complementarities. This is the first non-trivial algorithm for finding all pure-strategy Nash equilibria.