Results 1  10
of
21
Lazy Satisfiability Modulo Theories
 JOURNAL ON SATISFIABILITY, BOOLEAN MODELING AND COMPUTATION 3 (2007) 141Â224
, 2007
"... Satisfiability Modulo Theories (SMT) is the problem of deciding the satisfiability of a firstorder formula with respect to some decidable firstorder theory T (SMT (T)). These problems are typically not handled adequately by standard automated theorem provers. SMT is being recognized as increasingl ..."
Abstract

Cited by 189 (50 self)
 Add to MetaCart
Satisfiability Modulo Theories (SMT) is the problem of deciding the satisfiability of a firstorder formula with respect to some decidable firstorder theory T (SMT (T)). These problems are typically not handled adequately by standard automated theorem provers. SMT is being recognized as increasingly important due to its applications in many domains in different communities, in particular in formal verification. An amount of papers with novel and very efficient techniques for SMT has been published in the last years, and some very efficient SMT tools are now available. Typical SMT (T) problems require testing the satisfiability of formulas which are Boolean combinations of atomic propositions and atomic expressions in T, so that heavy Boolean reasoning must be efficiently combined with expressive theoryspecific reasoning. The dominating approach to SMT (T), called lazy approach, is based on the integration of a SAT solver and of a decision procedure able to handle sets of atomic constraints in T (Tsolver), handling respectively the Boolean and the theoryspecific components of reasoning. Unfortunately, neither the problem of building an efficient SMT solver, nor even that
Algorithms for Computing Minimal Unsatisfiable Subsets of Constraints
"... Abstract. Much research in the area of constraint processing has recently been focused on extracting small unsatisfiable “cores ” from unsatisfiable constraint systems with the goal of finding minimal unsatisfiable subsets (MUSes). While most techniques have provided ways to find an approximation of ..."
Abstract

Cited by 68 (9 self)
 Add to MetaCart
(Show Context)
Abstract. Much research in the area of constraint processing has recently been focused on extracting small unsatisfiable “cores ” from unsatisfiable constraint systems with the goal of finding minimal unsatisfiable subsets (MUSes). While most techniques have provided ways to find an approximation of an MUS (not necessarily minimal), we have developed a sound and complete algorithm for producing all MUSes of an unsatisfiable constraint system. In this paper, we describe a useful relationship between satisfiable and unsatisfiable subsets of constraints that we subsequently use as the foundation for MUS extraction algorithms, implemented for Boolean satisfiability constraints. The algorithms provide a framework with which many related subproblems can be solved, including relaxations of completeness to handle intractable instances, and we develop several variations of the basic algorithms to illustrate this. Experimental results demonstrate the performance of our algorithms, showing how the base algorithms run quickly on many instances, while the variations are valuable for producing results on instances whose complete results are intractably large. Furthermore, our algorithms are shown to perform better than the existing algorithms for solving either of the two distinct phases of our approach. 1.
Dependency Management for the Eclipse Ecosystem: Eclipse p2, Metadata and Resolution
, 2009
"... One of the strength of Eclipse, the wellknown open platform for software development, is its extensibility made possible by the builtin pluggability mechanisms. However those pluggability mechanisms only reveal their full potential when extensions created by others are made easy to distribute and ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
One of the strength of Eclipse, the wellknown open platform for software development, is its extensibility made possible by the builtin pluggability mechanisms. However those pluggability mechanisms only reveal their full potential when extensions created by others are made easy to distribute and obtain. The purpose of Eclipse p2 project is to build a platform addressing the challenges of distribution and obtention of Eclipse and its extensions, which poses the same dependency management issues than for component based systems. This paper focuses on the dependency management aspect of p2. It describes the metadata used to express dependencies, the overall functioning of our resolver and a description of our propositional constraints based encoding. To conclude we describe the challenges to address in future releases.
Lineartime reductions of resolution proofs
 HVC ’08: 4th Intl. Haifa Verification Conf. on Hardware and Software, volume 5394 of Lecture Notes in Computer Science
, 2009
"... Abstract. DPLLbased SAT solvers progress by implicitly applying binary resolution. The resolution proofs that they generate are used, after the SAT solver’s run has terminated, for various purposes. Most notable uses in formal verification are: extracting an unsatisfiable core, extracting an inter ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
(Show Context)
Abstract. DPLLbased SAT solvers progress by implicitly applying binary resolution. The resolution proofs that they generate are used, after the SAT solver’s run has terminated, for various purposes. Most notable uses in formal verification are: extracting an unsatisfiable core, extracting an interpolant, and detecting clauses that can be reused in an incremental satisfiability setting (the latter uses the proof only implicitly, during the run of the SAT solver). Making the resolution proof smaller can benefit all of these goals. We suggest two methods that are linear in the size of the proof for doing so. Our first technique, called RecycleUnits, uses each learned constant (unit clause) (x) for simplifying resolution steps in which x was the pivot, prior to when it was learned. Our second technique, called RecyclePivots, simplifies proofs in which there are several nodes in the resolution graph, one of which dominates the others, that correspond to the same pivot. Our experiments with industrial instances show that these simplifications reduce the core by ≈ 5 % and the proof by ≈ 13%. It reduces the core less than competing methods such as runtillfix, but whereas our algorithms are linear in the size of the proof, the latter and other competing techniques are all exponential as they are based on SAT runs. If we consider the size of the proof graph as being polynomial in the number of variables (it is not necessarily the case in general), this gives our method an exponential time reduction comparing to existing tools for small core extraction. Our experiments show that this result is evident in practice more so for the second method: rarely it takes more than a few seconds, even when competing tools time out, and hence it can be used as a cheap proof postprocessing procedure. 1
Computing small unsatisfiable cores in satisfiability modulo theories
 Journal of Artificial Intelligence Research
, 2011
"... Abstract The problem of finding small unsatisfiable cores for SAT formulas has recently received a lot of interest, mostly for its applications in formal verification. However, propositional logic is often not expressive enough for representing many interesting verification problems, which can be m ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
(Show Context)
Abstract The problem of finding small unsatisfiable cores for SAT formulas has recently received a lot of interest, mostly for its applications in formal verification. However, propositional logic is often not expressive enough for representing many interesting verification problems, which can be more naturally addressed in the framework of Satisfiability Modulo Theories, SMT. Surprisingly, the problem of finding unsatisfiable cores in SMT has received very little attention in the literature. In this paper we present a novel approach to this problem, called the LemmaLifting approach. The main idea is to combine an SMT solver with an external propositional core extractor. The SMT solver produces the theory lemmas found during the search, dynamically lifting the suitable amount of theory information to the Boolean level. The core extractor is then called on the Boolean abstraction of the original SMT problem and of the theory lemmas. This results in an unsatisfiable core for the original SMT problem, once the remaining theory lemmas are removed. The approach is conceptually interesting, and has several advantages in practice. In fact, it is extremely simple to implement and to update, and it can be interfaced with every propositional core extractor in a plugandplay manner, so as to benefit for free of all unsatcore reduction techniques which have been or will be made available. We have evaluated our algorithm with a very extensive empirical test on SMTLIB benchmarks, which confirms the validity and potential of this approach. Motivations and Goals In the last decade we have witnessed an impressive advance in the efficiency of SAT techniques, which has brought large and previouslyintractable problems at the reach of stateoftheart SAT solvers. As a consequence, SAT solvers are now a fundamental tool in many industrialstrength applications, including most formal verification design flows for hardware systems, for equivalence, property checking, and ATPG. In particular, one of the most relevant problems in this context, thanks to its many important applications, is that of finding small unsatisfiable cores, that is, small unsatisfiable subsets of unsatisfiable sets of clauses. Surprisingly, the problem of finding unsatisfiable cores in SMT has received virtually no attention in the literature. Although some SMT tools do compute unsat cores, this is done either as a byproduct of the more general task of producing proofs, or by modifying the embedded DPLL solver so that to apply basic propositional techniques to produce an unsat core. In particular, we are not aware of any work aiming at producing small unsatisfiable cores in SMT. In this paper we present a novel approach addressing this problem, which we call the LemmaLifting approach. The main idea is to combine an SMT solver with an external propositional core extractor. The SMT solver stores and returns the theory lemmas it had to prove in order to refute the input formula; the external core extractor is then called on the Boolean abstraction of the original SMT problem and of the theory lemmas. Our algorithm is based on the following two key observations: i) the theory lemmas discovered by the SMT solver during search are valid clauses in the theory T under consideration, and therefore they do not affect the satisfiability of a formula in T ; and ii) the conjunction of the original SMT formula with all the theory lemmas is propositionally unsatisfiable. Therefore, the external (Boolean) core extractor finds an unsatisfiable core for (the Boolean abstraction of) the conjunction of the original formula and the theory lemmas, which can then be refined back into a subset of the original clauses by simply removing from it (the Boolean abstractions of) all theory lemmas. The result is an unsatisfiable core of the original SMT problem. 702 Computing Small Unsatisfiable Cores in Satisfiability Modulo Theories Although simple in principle, the approach is conceptually interesting: basically, the SMT solver is used to dynamically lift the suitable amount of theory information to the Boolean level. Furthermore, the approach has several advantages in practice: first, it is extremely simple to implement and to update; second, it is effective in finding small cores; third, the core extraction is not prone to complex SMT reasoning; finally, it can be interfaced with every propositional core extractor in a plugandplay manner, so as to benefit for free of all unsatcore reduction techniques which have been or will be made available. We have evaluated our approach by a very extensive empirical test on SMTLIB benchmarks, in terms of both effectiveness (reduction in size of the cores) and efficiency (execution time). The results confirm the validity and versatility of this approach. As a byproduct, we have also produced an extensive and insightful evaluation of the main Boolean unsatcoregeneration tools currently available. Content. The paper is organized as follows. In §2 and §3 we provide some background knowledge on techniques for SAT and SMT ( §2), and for the extraction of unsatisfiable cores in SAT and in SMT ( §3). In §4 we present and discuss our new approach and algorithm. In §5 we present and comment on the empirical tests. In §6 we conclude, suggesting some future developments.
ExplanationBased Generalization of Infeasible Path
 In Proc. 3 rd Int. Conf. Software Testing, Verification and Validation (ICST’10
, 2010
"... Abstract—Recent codebased test input generators based on dynamic symbolic execution increase path coverage by solving path condition with a constraint or an SMT solver. When the solver considers path condition produced from an infeasible path, it tries to show unsatisfiability, which is a useless t ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
Abstract—Recent codebased test input generators based on dynamic symbolic execution increase path coverage by solving path condition with a constraint or an SMT solver. When the solver considers path condition produced from an infeasible path, it tries to show unsatisfiability, which is a useless timeconsuming process. In this paper, we propose a new method that takes opportunity of the detection of a single infeasible path to generalize to a (possibly infinite) family of infeasible paths, which will not have to be considered in further path conditions solving. The method exploits nonintrusive constraintbased explanations, a technique developed in Constraint Programming to explain unsatisfiability. Experimental results obtained with our prototype tool IPEG show that, whatever is the underlying constraint solving procedure (IC, Colibri and the SMT solver Z3), this approach can save considerable computational time. Index Terms—Dynamic symbolic execution; constraintbased explanation; test input generation I.
Branch and Bound for Boolean Optimization and the Generation of Optimality Certificates
"... Abstract. We consider optimization problems of the form (S, cost), where S is a clause set over Boolean variables x1... xn, with an arbitrary cost function cost: B n → R, and the aim is to find a model A of S such that cost(A) is minimized. Here we study the generation of proofs of optimality in the ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
(Show Context)
Abstract. We consider optimization problems of the form (S, cost), where S is a clause set over Boolean variables x1... xn, with an arbitrary cost function cost: B n → R, and the aim is to find a model A of S such that cost(A) is minimized. Here we study the generation of proofs of optimality in the context of branchandbound procedures for such problems. For this purpose we introduce DPLLBB, an abstract DPLLbased branch and bound algorithm that can model optimization concepts such as costbased propagation and costbased backjumping. Most, if not all, SATrelated optimization problems are in the scope of DPLLBB. Since many of the existing approaches for solving these problems can be seen as instances, DPLLBB allows one to formally reason about them in a simple way and exploit the enhancements of DPLLBB given here, in particular its uniform method for generating independently verifiable optimality proofs. 1
Exploring and Exploiting Algebraic and Graphical Properties of Resolution
"... Integrating an SMT solver in a certified environment such as an LFstyle proof assistant requires the solver to output proofs. Unfortunately, those proofs may be quite large, and the overhead of rechecking the proof may account for a significant fraction of the proof time. In this paper we explore t ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
Integrating an SMT solver in a certified environment such as an LFstyle proof assistant requires the solver to output proofs. Unfortunately, those proofs may be quite large, and the overhead of rechecking the proof may account for a significant fraction of the proof time. In this paper we explore techniques for reducing the sizes of propositional proofs, which are at the core of SMT proofs. Our techniques are justified in an algebra of resolution and rely on a graphtheoretical representation of proofs that allows us to detect the potential for reordering and combining resolution inferences. 1
Towards a Notion of Unsatisfiable Cores for LTL
, 2010
"... Unsatisfiable cores, i.e., parts of an unsatisfiable formula that are themselves unsatisfiable, have important uses in debugging specifications, speeding up search in model checking or SMT, and generating certificates of unsatisfiability. While unsatisfiable cores have been well investigated for Bo ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Unsatisfiable cores, i.e., parts of an unsatisfiable formula that are themselves unsatisfiable, have important uses in debugging specifications, speeding up search in model checking or SMT, and generating certificates of unsatisfiability. While unsatisfiable cores have been well investigated for Boolean SAT and constraint programming, the notion of unsatisfiable cores for temporal logics such as LTL has not received much attention. In this paper we investigate notions of unsatisfiable cores for LTL that arise from the syntax tree of an LTL formula, from converting it into a conjunctive normal form, and from proofs of its unsatisfiability. The resulting notions are more finegranular than existing ones.
Lineartime reductions of resolution proofs (full version
, 2008
"... Abstract. DPLLbased SAT solvers progress by implicitly applying binary resolution. The resolution proofs that they generate are used, after the SAT solver’s run has terminated, for various purposes. Most notable uses in formal verification are: extracting an unsatisfiable core, extracting an inter ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. DPLLbased SAT solvers progress by implicitly applying binary resolution. The resolution proofs that they generate are used, after the SAT solver’s run has terminated, for various purposes. Most notable uses in formal verification are: extracting an unsatisfiable core, extracting an interpolant, and detecting clauses that can be reused in an incremental satisfiability setting (the latter uses the proof only implicitly, during the run of the SAT solver). Making the resolution proof smaller can benefit all of these goals: it can lead to smaller cores, smaller interpolants, and smaller clauses that are propagated to the next SAT instance in an incremental setting. We suggest two methods that are linear in the size of the proof for doing so. Our first technique, called RecycleUnits, uses each learned constant (unit clause) (x) for simplifying resolution steps in which x was the pivot, prior to when it was learned. Our second technique, called RecyclePivots, simplifies proofs in which there are several nodes in the resolution graph, one of which dominates the others, that correspond to the same pivot. Our experiments with industrial instances show that these simplifications reduce the core by ≈ 5 % and the proof by ≈ 13%. It reduces the core less than competing methods such as runtillfix, but whereas our algorithms are linear in the size of the proof, the latter and other competing techniques are all exponential as they are based on SAT runs. If we consider the size of the proof graph as being polynomial in the number of variables (it is not necessarily the case in general), this gives our method an exponential time reduction comparing to existing tools for small core extraction. Our experiments show that this result is evident in practice more so for the second method: rarely it takes more than a few seconds, even when competing tools time out, and hence it can be used as a cheap proof postprocessing procedure. 1