2,012 research outputs found
Inverse Unfold Problem and Its Heuristic Solving
Unfold/fold transformations have been widely studied in various programming paradigms and are used in program transformations, theorem proving, and so on. This paper, by using an example, show that
restoring an one-step unfolding is not easy, i.e., a challenging task, since some rules used by unfolding may be lost. We formalize this problem by regarding one-step program transformation as a relation. Next we discuss some issues on a specific framework, called pure-constructor systems, which constitute a subclass of conditional term rewriting systems. We show that the inverse of T preserves rewrite relations if T preserves rewrite relations and the signature. We propose a heuristic procedure to solve the problem, and show its successful examples. We improve the procedure, and show examples for which the improvement takes effect
Conversion to Tail Recursion in Term Rewriting
NOTICE: this is the author’s version of a work that was accepted for publication in "Journal of Logic and Algebraic Programming". Changes resulting from the publishing process, such as peer review, editing, corrections, structural formatting, and other quality control mechanisms may not be reflected in this document. Changes may have been made to this work since it was submitted for publication. A definitive version was subsequently published in Journal of Logic and Algebraic Programming , vol. 83 issue 1, 2014 DOI 10.1016/j.jlap.2013.07.001Tail recursive functions are a special kind of recursive functions where the last action in
their body is the recursive call. Tail recursion is important for a number of reasons (e.g.,
they are usually more efficient). In this article, we introduce an automatic transformation
of first-order functions into tail recursive form. Functions are defined using a (first-order)
term rewrite system. We prove the correctness of the transformation for constructor-based
reduction over constructor systems (i.e., typical first-order functional programs).
© 2013 Elsevier Inc. All rights reservedThis work has been partially supported by the Spanish Ministerio de Ciencia e Innovacion (Secretaria de Estado de Investigation) under grant TIN2008-06622-C03-02, by the Generalitat Valenciana under grant PROMETEO/2011/052, and by MEXT KAKENHI #21700011.Nishida, N.; Vidal Oriola, GF. (2014). Conversion to Tail Recursion in Term Rewriting. Journal of Logic and Algebraic Programming. 83(1):53-63. https://doi.org/10.1016/j.jlap.2013.07.001S536383
Formal verification of language-based concurrent noninterference
We perform a formal analysis of compositionality techniques for proving possibilistic noninterference for a while language with parallel composition. We develop a uniform framework where we express a wide range of noninterference variants from the literature and compare them w.r.t. their contracts: the strength of the security properties they ensure weighed against the harshness of the syntactic conditions they enforce. This results in a simple implementable algorithm for proving that a program has a specific noninterference property, using only compositionality, which captures uniformly several security type-system results from the literature and suggests a further improved type system. All formalism and theorems have been mechanically verified in Isabelle/HOL
Reversible Computation in Term Rewriting
Essentially, in a reversible programming language, for each forward
computation from state to state , there exists a constructive method to
go backwards from state to state . Besides its theoretical interest,
reversible computation is a fundamental concept which is relevant in many
different areas like cellular automata, bidirectional program transformation,
or quantum computing, to name a few.
In this work, we focus on term rewriting, a computation model that underlies
most rule-based programming languages. In general, term rewriting is not
reversible, even for injective functions; namely, given a rewrite step , we do not always have a decidable method to get from
. Here, we introduce a conservative extension of term rewriting that
becomes reversible. Furthermore, we also define two transformations,
injectivization and inversion, to make a rewrite system reversible using
standard term rewriting. We illustrate the usefulness of our transformations in
the context of bidirectional program transformation.Comment: To appear in the Journal of Logical and Algebraic Methods in
Programmin
Formal verification of language-based concurrent noninterference
We perform a formal analysis of compositionality techniques for proving possibilistic noninterference for a while language with parallel composition. We develop a uniform framework where we express a wide range of noninterference variants from the literature and compare them w.r.t. their contracts: the strength of the security properties they ensure weighed against the harshness of the syntactic conditions they enforce. This results in a simple implementable algorithm for proving that a program has a specific noninterference property, using only compositionality, which captures uniformly several security type-system results from the literature and suggests a further improved type system. All formalism and theorems have been mechanically verified in Isabelle/HOL
- …