Results 1 
6 of
6
Efficient Ematching for SMT solvers
, 2007
"... Satisfiability Modulo Theories (SMT) solvers have proven highly scalable, efficient and suitable for integrating theory reasoning. However, for numerous applications from program analysis and verification, the ground fragment is insufficient, as proof obligations often include quantifiers. A well ..."
Abstract

Cited by 59 (10 self)
 Add to MetaCart
(Show Context)
Satisfiability Modulo Theories (SMT) solvers have proven highly scalable, efficient and suitable for integrating theory reasoning. However, for numerous applications from program analysis and verification, the ground fragment is insufficient, as proof obligations often include quantifiers. A well known approach for quantifier reasoning uses a matching algorithm that works against an Egraph to instantiate quantified variables. This paper introduces algorithms that identify matches on Egraphs incrementally and efficiently. In particular, we introduce an index that works on Egraphs, called Ematching code trees that combine features of substitution and code trees, used in saturation based theorem provers. Ematching code trees allow performing matching against several patterns simultaneously. The code trees are combined with an additional index, called the inverted path index, which filters Egraph terms that may potentially match patterns when the Egraph is updated. Experimental results show substantial performance improvements over existing stateoftheart SMT solvers.
Tabled HigherOrder Logic Programming
 In 20th International Conference on Automated Deduction
, 2003
"... Elf is a general metalanguage for the specification and implementation of logical systems in the style of the logical framework LF. Based on a logic programming interpretation, it supports executing logical systems and reasoning with and about them, thereby reducing the effort required for each ..."
Abstract

Cited by 34 (14 self)
 Add to MetaCart
(Show Context)
Elf is a general metalanguage for the specification and implementation of logical systems in the style of the logical framework LF. Based on a logic programming interpretation, it supports executing logical systems and reasoning with and about them, thereby reducing the effort required for each particular logical system. The traditional logic programming paradigm is extended by replacing firstorder terms with dependently typed terms and allowing implication and universal quantification in the bodies of clauses. These higherorder features allow us to model concisely and elegantly conditions on variables and the discharge of assumptions which are prevalent in many logical systems. However, many specifications are not executable under the traditional logic programming semantics and performance may be hampered by redundant computation. To address these problems, I propose a tabled higherorder logic programming interpretation for Elf. Some redundant computation is eliminated by memoizing subcomputation and reusing its result later. If we do not distinguish different proofs for a property, then search based on tabled logic programming is complete and terminates for programs with bounded recursion. In this proposal, I present a prooftheoretical characterization for tabled higherorder logic programming. It is the basis of the implemented prototype for tabled logic programming interpreter for Elf. Preliminary experiments indicate that many more logical specifications are executable under the tabled semantics. In addition, tabled computation leads to more efficient execution of programs. The goal of the thesis is to demonstrate that tabled logic programming allows us to efficiently automate reasoning with and about logical systems in the logical f...
Equational Prover of Theorema
, 2003
"... The equational prover of the Theorema system is described. It is implemented on Mathematica and is designed for unit equalities in the first order or in the applicative higher order form. A (restricted) usage of sequence variables and Mathematica builtin functions is allowed. ..."
Abstract

Cited by 7 (6 self)
 Add to MetaCart
The equational prover of the Theorema system is described. It is implemented on Mathematica and is designed for unit equalities in the first order or in the applicative higher order form. A (restricted) usage of sequence variables and Mathematica builtin functions is allowed.
Currying secondorder unification problems
 In: Proc. of the 13th International Conference on Rewriting Techniques and Applications. RTA’02. In: LNCS
, 2002
"... Abstract. The Curry form of a term, like f(a, b), allows us to write it, using just a single binary function symbol, as @(@(f,a),b). Using this technique we prove that the signature is not relevant in secondorder unification, and conclude that one binary symbol is enough. By currying variable appli ..."
Abstract

Cited by 7 (6 self)
 Add to MetaCart
(Show Context)
Abstract. The Curry form of a term, like f(a, b), allows us to write it, using just a single binary function symbol, as @(@(f,a),b). Using this technique we prove that the signature is not relevant in secondorder unification, and conclude that one binary symbol is enough. By currying variable applications, like X(a), as
Simplifying the signature in secondorder unification
, 2009
"... SecondOrder Unification is undecidable even for very specialized fragments. The signature plays a crucial role in these fragments. If all symbols are monadic, then the problem is NPcomplete, whereas it is enough to have just one binary constant to lose decidability. In this work we reduce SecondO ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
SecondOrder Unification is undecidable even for very specialized fragments. The signature plays a crucial role in these fragments. If all symbols are monadic, then the problem is NPcomplete, whereas it is enough to have just one binary constant to lose decidability. In this work we reduce SecondOrder Unification to SecondOrder Unification with a signature that contains just one binary function symbol and constants. The reduction is based on partially currying the equations by using the binary function symbol for explicit application @. Our work simplifies the study of SecondOrder Unification and some of its variants, like Context Unification and Bounded SecondOrder Unification.