1,679 research outputs found
Nominal C-Unification
Nominal unification is an extension of first-order unification that takes
into account the \alpha-equivalence relation generated by binding operators,
following the nominal approach. We propose a sound and complete procedure for
nominal unification with commutative operators, or nominal C-unification for
short, which has been formalised in Coq. The procedure transforms nominal
C-unification problems into simpler (finite families) of fixpoint problems,
whose solutions can be generated by algebraic techniques on combinatorics of
permutations.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854
Two Decades of Maude
This paper is a tribute to JosĂ© Meseguer, from the rest of us in the Maude team, reviewing the past, the present, and the future of the language and system with which we have been working for around two decades under his leadership. After reviewing the origins and the language's main features, we present the latest additions to the language and some features currently under development. This paper is not an introduction to Maude, and some familiarity with it and with rewriting logic are indeed assumed.Universidad de Málaga. Campus de Excelencia Internacional AndalucĂa Tech
New results on rewrite-based satisfiability procedures
Program analysis and verification require decision procedures to reason on
theories of data structures. Many problems can be reduced to the satisfiability
of sets of ground literals in theory T. If a sound and complete inference
system for first-order logic is guaranteed to terminate on T-satisfiability
problems, any theorem-proving strategy with that system and a fair search plan
is a T-satisfiability procedure. We prove termination of a rewrite-based
first-order engine on the theories of records, integer offsets, integer offsets
modulo and lists. We give a modularity theorem stating sufficient conditions
for termination on a combinations of theories, given termination on each. The
above theories, as well as others, satisfy these conditions. We introduce
several sets of benchmarks on these theories and their combinations, including
both parametric synthetic benchmarks to test scalability, and real-world
problems to test performances on huge sets of literals. We compare the
rewrite-based theorem prover E with the validity checkers CVC and CVC Lite.
Contrary to the folklore that a general-purpose prover cannot compete with
reasoners with built-in theories, the experiments are overall favorable to the
theorem prover, showing that not only the rewriting approach is elegant and
conceptually simple, but has important practical implications.Comment: To appear in the ACM Transactions on Computational Logic, 49 page
Canonized Rewriting and Ground AC Completion Modulo Shostak Theories : Design and Implementation
AC-completion efficiently handles equality modulo associative and commutative
function symbols. When the input is ground, the procedure terminates and
provides a decision algorithm for the word problem. In this paper, we present a
modular extension of ground AC-completion for deciding formulas in the
combination of the theory of equality with user-defined AC symbols,
uninterpreted symbols and an arbitrary signature disjoint Shostak theory X. Our
algorithm, called AC(X), is obtained by augmenting in a modular way ground
AC-completion with the canonizer and solver present for the theory X. This
integration rests on canonized rewriting, a new relation reminiscent to
normalized rewriting, which integrates canonizers in rewriting steps. AC(X) is
proved sound, complete and terminating, and is implemented to extend the core
of the Alt-Ergo theorem prover.Comment: 30 pages, full version of the paper TACAS'11 paper "Canonized
Rewriting and Ground AC-Completion Modulo Shostak Theories" accepted for
publication by LMCS (Logical Methods in Computer Science
Algebraic Principles for Rely-Guarantee Style Concurrency Verification Tools
We provide simple equational principles for deriving rely-guarantee-style
inference rules and refinement laws based on idempotent semirings. We link the
algebraic layer with concrete models of programs based on languages and
execution traces. We have implemented the approach in Isabelle/HOL as a
lightweight concurrency verification tool that supports reasoning about the
control and data flow of concurrent programs with shared variables at different
levels of abstraction. This is illustrated on two simple verification examples
The Algebraic Intersection Type Unification Problem
The algebraic intersection type unification problem is an important component
in proof search related to several natural decision problems in intersection
type systems. It is unknown and remains open whether the algebraic intersection
type unification problem is decidable. We give the first nontrivial lower bound
for the problem by showing (our main result) that it is exponential time hard.
Furthermore, we show that this holds even under rank 1 solutions (substitutions
whose codomains are restricted to contain rank 1 types). In addition, we
provide a fixed-parameter intractability result for intersection type matching
(one-sided unification), which is known to be NP-complete.
We place the algebraic intersection type unification problem in the context
of unification theory. The equational theory of intersection types can be
presented as an algebraic theory with an ACI (associative, commutative, and
idempotent) operator (intersection type) combined with distributivity
properties with respect to a second operator (function type). Although the
problem is algebraically natural and interesting, it appears to occupy a
hitherto unstudied place in the theory of unification, and our investigation of
the problem suggests that new methods are required to understand the problem.
Thus, for the lower bound proof, we were not able to reduce from known results
in ACI-unification theory and use game-theoretic methods for two-player tiling
games
Towards Correctness of Program Transformations Through Unification and Critical Pair Computation
Correctness of program transformations in extended lambda calculi with a
contextual semantics is usually based on reasoning about the operational
semantics which is a rewrite semantics. A successful approach to proving
correctness is the combination of a context lemma with the computation of
overlaps between program transformations and the reduction rules, and then of
so-called complete sets of diagrams. The method is similar to the computation
of critical pairs for the completion of term rewriting systems. We explore
cases where the computation of these overlaps can be done in a first order way
by variants of critical pair computation that use unification algorithms. As a
case study we apply the method to a lambda calculus with recursive
let-expressions and describe an effective unification algorithm to determine
all overlaps of a set of transformations with all reduction rules. The
unification algorithm employs many-sorted terms, the equational theory of
left-commutativity modelling multi-sets, context variables of different kinds
and a mechanism for compactly representing binding chains in recursive
let-expressions.Comment: In Proceedings UNIF 2010, arXiv:1012.455
Superposition as a logical glue
The typical mathematical language systematically exploits notational and
logical abuses whose resolution requires not just the knowledge of domain
specific notation and conventions, but not trivial skills in the given
mathematical discipline. A large part of this background knowledge is expressed
in form of equalities and isomorphisms, allowing mathematicians to freely move
between different incarnations of the same entity without even mentioning the
transformation. Providing ITP-systems with similar capabilities seems to be a
major way to improve their intelligence, and to ease the communication between
the user and the machine. The present paper discusses our experience of
integration of a superposition calculus within the Matita interactive prover,
providing in particular a very flexible, "smart" application tactic, and a
simple, innovative approach to automation.Comment: In Proceedings TYPES 2009, arXiv:1103.311
Reconciling Equational Heterogeneity within a Data Federation
Mappings in most federated databases are conceptualized and implemented as black-box transformations between source schemas and a federated schema. This approach does not allow specific mappings to be declared once and reused in other situations. We present an alternative approach, in which data-level mappings are represented independent of source and federated schemas as a network between “contexts”. This compendious representation expedites the data federation process via mapping reuse and automated mapping composition from simpler mappings. We illustrate the benefits of mapping reuse and composition by using an example that incorporates equational mappings and the application of symbolic equation solving techniques
- …