Results 1  10
of
97
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
(Show Context)
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
Extending Sledgehammer with SMT Solvers
"... Abstract. Sledgehammer is a component of Isabelle/HOL that employs firstorder automatic theorem provers (ATPs) to discharge goals arising in interactive proofs. It heuristically selects relevant facts and, if an ATP is successful, produces a snippet that replays the proof in Isabelle. We extended Sl ..."
Abstract

Cited by 47 (12 self)
 Add to MetaCart
Abstract. Sledgehammer is a component of Isabelle/HOL that employs firstorder automatic theorem provers (ATPs) to discharge goals arising in interactive proofs. It heuristically selects relevant facts and, if an ATP is successful, produces a snippet that replays the proof in Isabelle. We extended Sledgehammer to invoke satisfiability modulo theories (SMT) solvers as well, exploiting its relevance filter and parallel architecture. Isabelle users are now pleasantly surprised by SMT proofs for problems beyond the ATPs ’ reach. Remarkably, the best SMT solver performs better than the best ATP on most of our benchmarks. 1
A.: Cuts from proofs: A complete and practical technique for solving linear inequalities over integers
 In: In CAV
, 2009
"... Abstract. We propose a novel, sound, and complete Simplexbased algorithm for solving linear inequalities over integers. Our algorithm, which can be viewed as a semantic generalization of the branchandbound technique, systematically discovers and excludes entire subspaces of the solution space con ..."
Abstract

Cited by 23 (10 self)
 Add to MetaCart
(Show Context)
Abstract. We propose a novel, sound, and complete Simplexbased algorithm for solving linear inequalities over integers. Our algorithm, which can be viewed as a semantic generalization of the branchandbound technique, systematically discovers and excludes entire subspaces of the solution space containing no integer points. Our main insight is that by focusing on the defining constraints of a vertex, we can compute a proof of unsatisfiability for the intersection of the defining constraints and use this proof to systematically exclude subspaces of the feasible region with no integer points. We show experimentally that our technique significantly outperforms the top four competitors in the QFLIA category of the SMTCOMP ’08 when solving linear inequalities over integers. 1
Architecting solvers for SAT modulo theories: NelsonOppen with DPLL. Frontiers of Combining Systems
, 2007
"... Abstract. We offer a transition system representing a highlevel but detailed architecture for SMT solvers that combine a propositional SAT engine with solvers for multiple disjoint theories. The system captures succintly and accurately all the major aspects of the solver’s global operation: boolean ..."
Abstract

Cited by 20 (4 self)
 Add to MetaCart
(Show Context)
Abstract. We offer a transition system representing a highlevel but detailed architecture for SMT solvers that combine a propositional SAT engine with solvers for multiple disjoint theories. The system captures succintly and accurately all the major aspects of the solver’s global operation: boolean search with acrosstheboard backjumping, communication of theoryspecific facts and equalities between shared variables, and cooperative conflict analysis. Provably correct and prudently underspecified, our system is a readily usable ground for highquality implementations of comprehensive SMT solvers. 1
Bound Analysis of Imperative Programs with the Sizechange Abstraction
 IN: 18TH INT. STATIC ANALYSIS SYMPOSIUM
, 2011
"... The sizechange abstraction (SCA) is an important program abstraction for termination analysis, which has been successfully implemented in many tools for functional and logic programs. In this paper, we demonstrate that SCA is also a highly effective abstract domain for the bound analysis of imper ..."
Abstract

Cited by 19 (4 self)
 Add to MetaCart
(Show Context)
The sizechange abstraction (SCA) is an important program abstraction for termination analysis, which has been successfully implemented in many tools for functional and logic programs. In this paper, we demonstrate that SCA is also a highly effective abstract domain for the bound analysis of imperative programs. We have implemented a bound analysis tool based on SCA for imperative programs. We abstract programs in a pathwise and context dependent manner, which enables our tool to analyze realworld programs effectively. Our work shows that SCA captures many of the essential ideas of previous termination and bound analysis and goes beyond in a conceptually simpler framework.
Small Formulas for Large Programs: Online Constraint Simplification in Scalable Static Analysis
"... Abstract. Static analysis techniques that represent program states as formulas typically generate a large number of redundant formulas that are incrementally constructed from previous formulas. In addition to querying satisfiability and validity, analyses perform other operations on formulas, such a ..."
Abstract

Cited by 18 (9 self)
 Add to MetaCart
Abstract. Static analysis techniques that represent program states as formulas typically generate a large number of redundant formulas that are incrementally constructed from previous formulas. In addition to querying satisfiability and validity, analyses perform other operations on formulas, such as quantifier elimination, substitution, and instantiation, most of which are highly sensitive to formula size. Thus, the scalability of many static analysis techniques requires controlling the size of the generated formulas throughout the analysis. In this paper, we present a practical algorithm for reducing SMT formulas to a simplified form containing no redundant subparts. We present experimental evidence that online simplification of formulas dramatically improves scalability. 1
Sword: A SAT like prover using word level information
 In VLSI of SystemonChip
, 2007
"... Abstract. Solvers for Boolean Satisfiability (SAT) are stateoftheart to solve verification problems. But when arithmetic operations are considered, the verification performance degrades with increasing datapath width. Therefore, several approaches that handle a higher level of abstraction have ..."
Abstract

Cited by 17 (9 self)
 Add to MetaCart
(Show Context)
Abstract. Solvers for Boolean Satisfiability (SAT) are stateoftheart to solve verification problems. But when arithmetic operations are considered, the verification performance degrades with increasing datapath width. Therefore, several approaches that handle a higher level of abstraction have been studied in the past. But the resulting solvers are still not robust enough to handle problems that mix word level structures with bit level descriptions. In this paper, we present the satisfiability solver SWORD a SAT like solver that facilitates word level information. SWORD represents the problem in terms of modules that define operations over bit vectors. Thus, word level information and structural knowledge become available in the search process. The experimental results show that on our benchmarks SWORD is more robust than Boolean SAT, K*BMDs or SMT.
Separation Logic + Superposition Calculus = Heap Theorem Prover
 PLDI'11
, 2011
"... Program analysis and verification tools crucially depend on the ability to symbolically describe and reason about sets of program behaviors. Separation logic provides a promising foundation for dealing with heap manipulating programs, while the development of practical automated deduction/satisfiabi ..."
Abstract

Cited by 16 (1 self)
 Add to MetaCart
Program analysis and verification tools crucially depend on the ability to symbolically describe and reason about sets of program behaviors. Separation logic provides a promising foundation for dealing with heap manipulating programs, while the development of practical automated deduction/satisfiability checking tools for separation logic is a challenging problem. In this paper, we present an efficient, sound and complete automated theorem prover for checking validity of entailments between separation logic formulas with list segment predicates. Our theorem prover integrates separation logic inference rules that deal with list segments and a superposition calculus to deal with equality/aliasing between memory locations. The integration follows a modular combination approach that allows one to directly incorporate existing advanced techniques for firstorder reasoning with equality, as well as account for additional theories, e.g., linear arithmetic, using extensions of superposition. An experimental evaluation of our entailment prover indicates speedups of several orders of magnitude with respect to the available stateoftheart tools.
CLAP: Recording Local Executions to Reproduce Concurrency Failures
"... We present CLAP, a new technique to reproduce concurrency bugs. CLAP has two key steps. First, it logs thread local execution paths at runtime. Second, offline, it computes memory dependencies that accord with the logged execution and are able to reproduce the observed bug. The second step works by ..."
Abstract

Cited by 14 (3 self)
 Add to MetaCart
(Show Context)
We present CLAP, a new technique to reproduce concurrency bugs. CLAP has two key steps. First, it logs thread local execution paths at runtime. Second, offline, it computes memory dependencies that accord with the logged execution and are able to reproduce the observed bug. The second step works by combining constraints from the thread paths and constraints based on a memory model, and computing an execution with a constraint solver. CLAP has four major advantages. First, logging purely local execution of each thread is substantially cheaper than logging memory interactions, which enables CLAP to be efficient compared to previous approaches. Second, our logging does not require any synchronization and hence with no added memory barriers or fences; this minimizes perturbation and missed bugs due to extra synchronizations foreclosing certain racy behaviors. Third, since it uses no synchronization, we extend CLAP to work on a range of relaxed memory models, such as TSO and PSO, in addition to sequential consistency. Fourth, CLAP can compute a much simpler execution than the original one, that reveals the bug with minimal thread context switches. To mitigate the scalability issues, we also present an approach to parallelize constraint solving, which theoretically scales our technique to programs with arbitrary execution length. Experimental results on a variety of multithreaded benchmarks and real world concurrent applications validate these advantages by showing that our technique is effective in reproducing concurrency bugs even under relaxed memory models; furthermore, it is significantly more efficient than a stateoftheart technique that records shared memory dependencies, reducing execution time overhead by 45 % and log size by 88 % on average. 1.
Abstract Domains of Affine Relations
"... This paper considers some known abstract domains for affinerelation analysis (ARA), along with several variants, and studies how they relate to each other. We show that the abstract domains of MüllerOlm/Seidl (MOS) and King/Søndergaard (KS) are, in general, incomparable, but give sound interconve ..."
Abstract

Cited by 14 (8 self)
 Add to MetaCart
(Show Context)
This paper considers some known abstract domains for affinerelation analysis (ARA), along with several variants, and studies how they relate to each other. We show that the abstract domains of MüllerOlm/Seidl (MOS) and King/Søndergaard (KS) are, in general, incomparable, but give sound interconversion methods. We also show that the methods of King and Søndergaard can be applied without bitblasting—while still using a bitprecise concrete semantics.