623 research outputs found
Methods for Proving Termination of Rewriting-based Programming Languages by Transformation
AbstractDespite the remarkable development of the theory of termination of rewriting, its application to high-level (rewriting-based) programming languages is far from being optimal. This is due to the need for features such as conditional equations and rules, types and subtypes, (possibly programmable) strategies for controlling the execution, matching modulo axioms, and so on, that are used in many programs and tend to place such programs outside the scope of current termination tools. The operational meaning of such features is often formalized in a proof theoretic manner by means of an inference system rather than just by a rewriting relation. The corresponding termination notions can also differ from the standard ones. During the last years we have introduced and implemented different notions and transformation techniques which have been proved useful for proving and disproving termination of such programs by using existing tools for proving termination of (variants of) rewriting. In this paper we provide an overview of our main contributions
Set Unification
The unification problem in algebras capable of describing sets has been
tackled, directly or indirectly, by many researchers and it finds important
applications in various research areas--e.g., deductive databases, theorem
proving, static analysis, rapid software prototyping. The various solutions
proposed are spread across a large literature. In this paper we provide a
uniform presentation of unification of sets, formalizing it at the level of set
theory. We address the problem of deciding existence of solutions at an
abstract level. This provides also the ability to classify different types of
set unification problems. Unification algorithms are uniformly proposed to
solve the unification problem in each of such classes.
The algorithms presented are partly drawn from the literature--and properly
revisited and analyzed--and partly novel proposals. In particular, we present a
new goal-driven algorithm for general ACI1 unification and a new simpler
algorithm for general (Ab)(Cl) unification.Comment: 58 pages, 9 figures, 1 table. To appear in Theory and Practice of
Logic Programming (TPLP
AC-KBO Revisited
Equational theories that contain axioms expressing associativity and
commutativity (AC) of certain operators are ubiquitous. Theorem proving methods
in such theories rely on well-founded orders that are compatible with the AC
axioms. In this paper we consider various definitions of AC-compatible
Knuth-Bendix orders. The orders of Steinbach and of Korovin and Voronkov are
revisited. The former is enhanced to a more powerful version, and we modify the
latter to amend its lack of monotonicity on non-ground terms. We further
present new complexity results. An extension reflecting the recent proposal of
subterm coefficients in standard Knuth-Bendix orders is also given. The various
orders are compared on problems in termination and completion.Comment: 31 pages, To appear in Theory and Practice of Logic Programming
(TPLP) special issue for the 12th International Symposium on Functional and
Logic Programming (FLOPS 2014
Towards a Framework for Proving Termination of Maude Programs
Maude es un lenguaje de programación declarativo basado en la lógica de reescritura
que incorpora muchas características que lo hacen muy potente. Sin
embargo, a la hora de probar ciertas propiedades computacionales esto conlleva
dificultades. La tarea de probar la terminación de sistemas de reesctritura
es de hecho bastante dura, pero aplicada a lenguajes de programación reales
se concierte en más complicada debido a estas características inherentes. Esto
provoca que métodos para probar la terminación de este tipo de programas
requieran técnicas específicas y un análisis cuidadoso. Varios trabajos han intentado
probar terminación de (un subconjunto de) programas Maude. Sin
embargo, todos ellos siguen una aproximación transformacional, donde el programa
original es trasformado hasta alcanzar un sistema de reescritura capaz
de ser manejado con las técnicas y herramientas de terminación existentes. En
la práctica, el hecho de transformar los sistemas originales suele complicar la
demostración de la terminación ya que esto introduce nuevos símbolos y reglas
en el sistema. En esta tesis, llevamos a cabo el problema de probar terminación
de (un subconjunto de) programas Maude mediante métodos directos.
Por un lado, nos centramos en la estrategia de Maude. Maude es un lenguaje
impaciente donde los argumentos de una función son evaluados siempre
antes de la aplicación de la función que los usa. Esta estrategia (conocida como
llamada por valor) puede provocar la no terminación si los programas no
están escritos cuidadosamente. Por esta razón, Maude (en concreto) incorpora
mecanismos para controlar la ejecución de programas como las anotaciones
sintácticas que están asociadas a los argumentos de los símbolos. En reescritura,
esta estrategia sería conocida como reescritura sensible al contexto
innermost (RSCI).
Por otro lado, Maude también incorpora la posibilidad de declarar atributos.Alarcón Jiménez, B. (2011). Towards a Framework for Proving Termination of Maude Programs [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/11003Palanci
New Equations for Neutral Terms: A Sound and Complete Decision Procedure, Formalized
The definitional equality of an intensional type theory is its test of type
compatibility. Today's systems rely on ordinary evaluation semantics to compare
expressions in types, frustrating users with type errors arising when
evaluation fails to identify two `obviously' equal terms. If only the machine
could decide a richer theory! We propose a way to decide theories which
supplement evaluation with `-rules', rearranging the neutral parts of
normal forms, and report a successful initial experiment.
We study a simple -calculus with primitive fold, map and append operations on
lists and develop in Agda a sound and complete decision procedure for an
equational theory enriched with monoid, functor and fusion laws
Use of Logical Models for Proving Operational Termination in General Logics
The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-319-44802-2_2[EN] A declarative programming language is based on some logic L and its operational semantics is given by a proof calculus which is often presented in a natural deduction style by means of inference rules. Declarative programs are theories S of L and executing a program is proving goals ϕ in the inference system I(S) associated to S as a particulariza-tion of the inference system of the logic. The usual soundness assumption for L implies that every model A of S also satisfies ϕ. In this setting, the operational termination of a declarative program is quite naturally defined as the absence of infinite proof trees in the inference system I(S). Proving operational termination of declarative programs often involves two main ingredients: (i) the generation of logical models A to abstract the program execution (i.e., the provability of specific goals in I(S)), and (ii) the use of well-founded relations to guarantee the absence of infinite branches in proof trees and hence of infinite proof trees, possibly taking into account the information about provability encoded by A. In this paper we show how to deal with (i) and (ii) in a uniform way. The main point is the synthesis of logical models where well-foundedness is a side requirement for some specific predicate symbols.Partially supported by the EU (FEDER), Spanish MINECO TIN 2013-45732-C4-1-P and TIN2015-69175-C4-1-R, and GV PROMETEOII/2015/013.Lucas Alba, S. (2016). Use of Logical Models for Proving Operational Termination in General Logics. Lecture Notes in Computer Science. 9942:26-46. https://doi.org/10.1007/978-3-319-44802-2S2646994
PML2: Integrated Program Verification in ML
We present the PML_2 language, which provides a uniform environment for programming, and for proving properties of programs in an ML-like setting. The language is Curry-style and call-by-value, it provides a control operator (interpreted in terms of classical logic), it supports general recursion and a very general form of (implicit, non-coercive) subtyping. In the system, equational properties of programs are expressed using two new type formers, and they are proved by constructing terminating programs. Although proofs rely heavily on equational reasoning, equalities are exclusively managed by the type-checker. This means that the user only has to choose which equality to use, and not where to use it, as is usually done in mathematical proofs. In the system, writing proofs mostly amounts to applying lemmas (possibly recursive function calls), and to perform case analyses (pattern matchings)
State space c-reductions for concurrent systems in rewriting logic
We present c-reductions, a state space reduction technique.
The rough idea is to exploit some equivalence relation on states (possibly capturing system regularities) that preserves behavioral properties, and explore the induced quotient system. This is done by means of a canonizer
function, which maps each state into a (non necessarily unique) canonical representative of its equivalence class. The approach exploits the expressiveness of rewriting logic and its realization in Maude to enjoy several advantages over similar approaches: exibility and simplicity in
the definition of the reductions (supporting not only traditional symmetry reductions, but also name reuse and name abstraction); reasoning support for checking and proving correctness of the reductions; and automatization
of the reduction infrastructure via Maude's meta-programming
features. The approach has been validated over a set of representative case studies, exhibiting comparable results with respect to other tools
- …