Exponential Blow-up Research Articles

A New Look at BDDs for Pseudo-Boolean Constraints

Pseudo-Boolean constraints are omnipresent in practical applications, and thus a significant effort has been devoted to the development of good SAT encoding techniques for them. Some of these encodings first construct a Binary Decision Diagram (BDD) for the constraint, and then encode the BDD into a propositional formula. These BDD-based approaches have some important advantages, such as not being dependent on the size of the coefficients, or being able to share the same BDD for representing many constraints. We first focus on the size of the resulting BDDs, which was considered to be an open problem in our research community. We report on previous work where it was proved that there are Pseudo-Boolean constraints for which no polynomial BDD exists. We also give an alternative and simpler proof assuming that NP is different from Co-NP. More interestingly, here we also show how to overcome the possible exponential blowup of BDDs by \emph{coefficient decomposition}. This allows us to give the first polynomial generalized arc-consistent ROBDD-based encoding for Pseudo-Boolean constraints. Finally, we focus on practical issues: we show how to efficiently construct such ROBDDs, how to encode them into SAT with only 2 clauses per node, and present experimental results that confirm that our approach is competitive with other encodings and state-of-the-art Pseudo-Boolean solvers.

Chiefly Symmetric: Results on the Scalability of Probabilistic Model Checking for Operating-System Code

Reliability in terms of functional properties from the safety-liveness spectrum is an indispensable requirement of low-level operating-system (OS) code. However, with evermore complex and thus less predictable hardware, quantitative and probabilistic guarantees become more and more important. Probabilistic model checking is one technique to automatically obtain these guarantees. First experiences with the automated quantitative analysis of low-level operating-system code confirm the expectation that the naive probabilistic model checking approach rapidly reaches its limits when increasing the numbers of processes. This paper reports on our work-in-progress to tackle the state explosion problem for low-level OS-code caused by the exponential blow-up of the model size when the number of processes grows. We studied the symmetry reduction approach and carried out our experiments with a simple test-and-test-and-set lock case study as a representative example for a wide range of protocols with natural inter-process dependencies and long-run properties. We quickly see a state-space explosion for scenarios where inter-process dependencies are insignificant. However, once inter-process dependencies dominate the picture models with hundred and more processes can be constructed and analysed.

Phragmén-Lindelöf alternative for an exact heat conduction equation with delay

In this paper we investigate the spatial behavior of the solutions for a theory for the heat conduction with one delay term. We obtain a Phragmén-Lindelöf type alternative. That is, the solutions either decay in an exponential way or blow-up at infinity in an exponential way. We also show how to obtain an upper bound for the amplitude term. Later we point out how to extend the results to a thermoelastic problem. We finish the paper by considering the equation obtained by the Taylor approximation to the delay term. A Phragmén-Lindelöf type alternative is obtained for the forward and backward in time equations.

Efficiently solving quantified bit-vector formulas

In recent years, bit-precise reasoning has gained importance in hardware and software verification. Of renewed interest is the use of symbolic reasoning for synthesising loop invariants, ranking functions, or whole program fragments and hardware circuits. Solvers for the quantifier-free fragment of bit-vector logic exist and often rely on SAT solvers for efficiency. However, many techniques require quantifiers in bit-vector formulas to avoid an exponential blow-up during construction. Solvers for quantified formulas usually flatten the input to obtain a quantified Boolean formula, losing much of the word-level information in the formula. We present a new approach based on a set of effective word-level simplifications that are traditionally employed in automated theorem proving, heuristic quantifier instantiation methods used in SMT solvers, and model finding techniques based on skeletons/templates. Experimental results on two different types of benchmarks indicate that our method outperforms the traditional flattening approach by multiple orders of magnitude of runtime.

Series Parallel Digraphs with Loops

In the conversion of finite automata to regular expressions, an exponential blowup in size can generally not be avoided. This is due to graph-structural properties of automata which cannot be directly encoded by regular expressions and cause the blowup combinatorially. In order to identify these structures, we generalize the class of arc-series-parallel digraphs beyond the acyclic case. The resulting digraphs are shown to be reversibly encoded by linear-sized regular expressions. Also, a characterization of this new class by a set of seven forbidden substructures is given. Automata that require expressions of superlinear size must contain some of these substructures.

The size-cost of Boolean operations on constant height deterministic pushdown automata

We study the size-cost of Boolean operations on constant height deterministic pushdown automata, i.e., on the traditional pushdown automata with a built-in constant limit on the height of the pushdown. We design a simulation showing that a complement can be obtained with a polynomial tradeoff. For intersection and union, we show an exponential simulation, and prove that the exponential blow-up cannot be avoided.

An alternating hierarchy for finite automata

We study the polynomial state complexity classes 2Σk and 2Πk, that is, the hierarchy of problems that can be solved with a polynomial number of states by two-way alternating finite automata (2Afas) making at most k−1 alternations between existential and universal states, starting in an existential or universal state, respectively. This hierarchy is infinite: for k=2,3,4,…, both 2Σk−1 and 2Πk−1 are proper subsets of 2Σk and of 2Πk, since the conversion of a one-way Σk- or Πk-alternating automaton with n states into a two-way automaton with a smaller number of alternations requires 2n/4−O(k) states. The same exponential blow-up is required for converting a Σk-bounded 2Afa into a Πk-bounded 2Afa and vice versa, that is, 2Σk and 2Πk are incomparable. In the case of Σk-bounded 2Afas, the exponential gap applies also for intersection, while in the case of Πk-bounded 2Afas for union. The same results are established for one-way alternating finite automata.This solves several open problems raised in [C. Kapoutsis, Size complexity of two-way finite automata, in: Proc. Develop. Lang. Theory, in: Lect. Notes Comput. Sci., vol. 5583, Springer-Verlag, 2009, pp. 47–66.]

The Computational Complexity of Nash Equilibria in Concisely Represented Games

Games may be represented in many different ways, and different representations of games affect the complexity of problems associated with games, such as finding a Nash equilibrium. The traditional method of representing a game is to explicitly list all the payoffs, but this incurs an exponential blowup as the number of agents grows. We study two models of concisely represented games: circuit games , where the payoffs are computed by a given boolean circuit, and graph games , where each agent’s payoff is a function of only the strategies played by its neighbors in a given graph. For these two models, we study the complexity of four questions: determining if a given strategy is a Nash equilibrium, finding a Nash equilibrium, determining if there exists a pure Nash equilibrium, and determining if there exists a Nash equilibrium in which the payoffs to a player meet some given guarantees. In many cases, we obtain tight results, showing that the problems are complete for various complexity classes.

Descriptional complexity of two-way pushdown automata with restricted head reversals

Two-way nondeterministic pushdown automata (2PDA) are classical nondeterministic pushdown automata (PDA) enhanced with two-way motion of the input head. In this paper, the subclass of 2PDA accepting bounded languages and making at most a constant number of input head turns is studied with respect to descriptional complexity aspects. In particular, the effect of reducing the number of pushdown reversals to a constant number is of interest. It turns out that this reduction leads to an exponential blow-up in case of nondeterministic devices, and to a doubly-exponential blow-up in case of deterministic devices. If the restriction on boundedness of the languages considered and on the finiteness of the number of head and pushdown turns is dropped, the resulting trade-offs are no longer bounded by recursive functions, and so-called non-recursive trade-offs are shown.

Parameter reduction and automata evaluation for grammar-compressed trees

Trees can be conveniently compressed with linear straight-line context-free tree grammars. Such grammars generalize straight-line context-free string grammars which are widely used in the development of algorithms that execute directly on compressed structures (without prior decompression). It is shown that every linear straight-line context-free tree grammar can be transformed in polynomial time into a monadic (and linear) one. A tree grammar is monadic if each nonterminal uses at most one context parameter. Based on this result, polynomial time algorithms are presented for testing whether a given (i) nondeterministic tree automaton or (ii) nondeterministic tree automaton with sibling-constraints or (iii) nondeterministic tree walking automaton, accepts a tree represented by a linear straight-line context-free tree grammar. It is also shown that if tree grammars are nondeterministic or non-linear, then reducing their numbers of parameters cannot be done without an exponential blow-up in grammar size.

MULTI-GRANULARITY KNOWLEDGE MINING ON THE WEB

We tackle the problem of knowledge mining on the Web. In this paper, we propose MGKM algebraic system for iterative search documents sets, and then develop an approach to extract topics on the web with Multi-Granularity Knowledge Mining algorithm (MGKM). The proposed approach maps the data space of the original method to a vector space of sentence, improving the original DBCO algorithm. We outline the interface between our scheme and the current data Web, and show that, in contrast to the existing approaches, no exponential blowup is produced by the MGKM. Based on the experiments with real-world data sets of 310 users in three study sites, we demonstrate that knowledge mining in the proposed approach is efficient, especially for large-scale web learning resources. According to the user ratings data of four learning sites in the 150 days, the average rate of increase of user rating after the system is used reaches 25.18%.

Efficient emptiness check for timed Büchi automata

The B\"uchi non-emptiness problem for timed automata refers to deciding if a given automaton has an infinite non-Zeno run satisfying the B\"uchi accepting condition. The standard solution to this problem involves adding an auxiliary clock to take care of the non-Zenoness. In this paper, it is shown that this simple transformation may sometimes result in an exponential blowup. A construction avoiding this blowup is proposed. It is also shown that in many cases, non-Zenoness can be ascertained without extra construction. An on-the-fly algorithm for the non-emptiness problem, using non-Zenoness construction only when required, is proposed. Experiments carried out with a prototype implementation of the algorithm are reported.

On symbolic OBDD-based algorithms for the minimum spanning tree problem

The minimum spanning tree problem is one of the most fundamental algorithmic graph problems and OBDDs are a very common dynamic data structure for Boolean functions. Since in some applications graphs become larger and larger, a research branch has emerged which is concerned with the design and analysis of so-called symbolic algorithms for classical graph problems on OBDD-represented graph instances. Here, a symbolic minimum spanning tree algorithm using O(log3|V|) functional operations is presented, where V is the set of vertices of the input graph. Moreover, the computation of the transitive closure is investigated and it is proved that there can be an exponential blow-up from input to output size. Furthermore, answering an open problem posed by Sawitzki [37] it is shown that every symbolic OBDD-based algorithm for the minimum spanning tree problem needs exponential space (with respect to the OBDD size of the input graph). This result even holds for planar input graphs.

Averaging theorems for the large-time behavior of the solutions of nonautonomous systems

We obtain some averaging theorems for the large-time behavior of an evolution family { U ( t , s ) } t ≥ s ≥ 0 acting on a Banach space. It is known that, if a trajectory U ( ⋅ , t 0 ) x 0 is asymptotically stable, then its p -mean tends to zero. We will show here that, if the uniformly weighted p -means of all the trajectories starting on the unit sphere are bounded, then { U ( t , s ) } t ≥ s ≥ 0 is uniformly exponentially stable, while the converse statement is a simple verification. Discrete-time versions of this result are given. Also, variants for the uniform exponential blow-up are obtained. Thus, we generalize some known results obtained by R. Datko, A. Pazy, and V. Pata.

Exponential energy decay and blow-up of solutions for a system of nonlinear viscoelastic wave equations with strong damping

Abstract In this paper, we consider the system of nonlinear viscoelastic equations u t t - Δ u + ∫ 0 t g 1 ( t - τ ) Δ u ( τ ) d τ - Δ u t = f 1 ( u , v ) , ( x , t ) ∈ Ω × ( 0 , T ) , v t t - Δ v + ∫ 0 t g 2 ( t - τ ) Δ v ( τ ) d τ - Δ v t = f 2 ( u , v ) , ( x , t ) ∈ Ω × ( 0 , T ) with initial and Dirichlet boundary conditions. We prove that, under suitable assumptions on the functions g i , f i (i = 1, 2) and certain initial data in the stable set, the decay rate of the solution energy is exponential. Conversely, for certain initial data in the unstable set, there are solutions with positive initial energy that blow up in finite time. 2000 Mathematics Subject Classifications: 35L05; 35L55; 35L70.

Finding and fixing faults

Knowing that a program has a bug is good, knowing its location is better, but a fix is best. We present a method to automatically locate and correct faults in a finite state system, either at the gate level or at the source level. We assume that the specification is given in Linear Temporal Logic, and state the correction problem as a game, in which the protagonist selects a faulty component and suggests alternative behavior. The basic approach is complete but as complex as synthesis. It also suffers from problems of readability: the correction may add state and logic to the system. We present two heuristics. The first avoids the doubly exponential blowup associated with synthesis by using nondeterministic automata. The second heuristic finds a memoryless strategy, which we show is an NP-complete problem. A memoryless strategy corresponds to a simple, local correction that does not add any state. The drawback of the two heuristics is that they are not complete unless the specification is an invariant. Our approach is general: the user can define what constitutes a component, and the suggested correction can be an arbitrary combinational function of the current state and the inputs. We show experimental results supporting the applicability of our approach.

Cycle elimination for invocation graph-based context-sensitive pointer analysis

Context Pointer analysis is an important building block of optimizing compilers and program analyzers for C language. Various methods with precision and performance trade-offs have been proposed. Among them, cycle elimination has been successfully used to improve the scalability of context-insensitive pointer analyses without losing any precision. Objective In this article, we present a new method on context-sensitive pointer analysis with an effective application of cycle elimination. Method To obtain similar benefits of cycle elimination for context-sensitive analysis, we propose a novel constraint-based formulation that uses sets of contexts as annotations. Our method is not based on binary decision diagram (BDD). Instead, we directly use invocation graphs to represent context sets and apply a hash-consing technique to deal with the exponential blow-up of contexts. Result Experimental results on C programs ranging from 20,000 to 290,000 lines show that applying cycle elimination to our new formulation results in 4.5 ×speedup over the previous BDD-based approach. Conclusion We showed that cycle elimination is an effective method for improving the scalability of context-sensitive pointer analysis.

Scaling Up Multiagent Planning: A Best-Response Approach

Multiagent planning is computationally hard in the general case due to the exponential blowup in the action space induced by concurrent action of different agents. At the same time, many scenarios require the computation of plans that are strategically meaningful for self-interested agents, in order to ensure that there would be sufficient incentives for those agents to participate in a joint plan. In this paper, we present a multiagent planning and plan improvement method that is based on conducting iterative best-response planning using standard single-agent planning algorithms. In constrained types of planning scenarios that correspond to congestion games, this is guaranteed to converge to a plan that is a Nash equilibrium with regard to agents' preference profiles over the entire plan space. Our empirical evaluation beyond these restricted scenarios shows, however, that the algorithm has much broader applicability as a method for plan improvement in general multiagent planning problems. Extensive empirical experiments in various domains illustrate the scalability of our method in both cases.

A New Intelligent Topic Extraction Model on Web

We tackle the problem of topic extraction on Web. In this paper, we propose an approach to implementing ontology-based data access in WordNet with the distinguishing feature of optimizing density-based clustering OPTICS algorithm (DBCO) to extract topics. Our solution has the following two desirable properties: i) it uses WordNet for word sense disambiguation of words in the learning resources documents and ii) it mapping the data space of the original method to a vector space of sentence, improving the original OPTICS algorithm. We outline the interface between our scheme and the current data Web, and show that, in contrast to the existing approaches, no exponential blowup is produced by the DBCO. Based on the experiments with a number of real-world data sets of 310 users in three study sites, we demonstrate that topic extraction in the proposed approach is efficient, especially for large-scale web learning resources. According to the user ratings data of four learning sites in the 150 days, the average rate of increase of user rating after the system is used reaches 25.18%.

Translation from classical two-way automata to pebble two-way automata

We study the relation between the standard two-way automata and more powerful devices, namely, two-way finite automata equipped with some additional “pebbles” that are movable along the input tape, but their use is restricted (nested) in a stack-like fashion. Similarly as in the case of the classical two-way machines, it is not known whether there exists a polynomial trade-off, in the number of states, between the nondeterministic and deterministic two-way automata with nested pebbles. However, we show that these two machine models are not independent: if there exists a polynomial trade-off for the classical two-way automata, then, for each ≥ 0, there must also exist a polynomial trade-off for the two-way automata with nested pebbles. Thus, we have an upward collapse (or a downward separation) from the classical two-way automata to more powerful pebble automata, still staying within the class of regular languages. The same upward collapse holds for complementation of nondeterministic two-way machines. These results are obtained by showing that each pebble machine can be, by using suitable inputs, simulated by a classical two-way automaton (and vice versa), with only a linear number of states, despite the existing exponential blow-up between the classical and pebble two-way machines.