98,899 research outputs found
CAN WE TRANSFORM LOGIC PROGRAMS INTO ATTRIBUTE GRAMMARS?
In this paper we study the relationship between Attribute Grammars and Logic Programs,
concentrating on transforming logic programs into attribute grammars. This
has potential applications in compilation techniques for logic programs. It does not
seem possible to transform arbitrary Logic Programs into Attribute Grammars, basically
because the same logic variables can sometimes be used as input and sometimes as
output. We introduce the notion of an Abstract Attribute Grammar, which is similar to
that of an Attribute Grammar with the exception that attributes are not classified into
inherited and synthesized, and that the semantic equations are replaced by restriction
sets. These sets represent a restriction on the values of attribute occurrences namely,
all elements within each set have to be equal. We give an effective translation schema
which produces an equivalent Abstract Attribute Grammar for a given Logic Program.
We provide a formal proof of this equivalence. We then proceed to classify a class
of Abstract Attribute Grammars that can be transformed into Attribute Grammars,
and show how to achieve this transformation. By composing both transformations one
can transform certain logic programs into attribute grammars. Complete proofs ar5e
given.Information Systems Working Papers Serie
Finite Countermodel Based Verification for Program Transformation (A Case Study)
Both automatic program verification and program transformation are based on
program analysis. In the past decade a number of approaches using various
automatic general-purpose program transformation techniques (partial deduction,
specialization, supercompilation) for verification of unreachability properties
of computing systems were introduced and demonstrated. On the other hand, the
semantics based unfold-fold program transformation methods pose themselves
diverse kinds of reachability tasks and try to solve them, aiming at improving
the semantics tree of the program being transformed. That means some
general-purpose verification methods may be used for strengthening program
transformation techniques. This paper considers the question how finite
countermodels for safety verification method might be used in Turchin's
supercompilation method. We extract a number of supercompilation sub-algorithms
trying to solve reachability problems and demonstrate use of an external
countermodel finder for solving some of the problems.Comment: In Proceedings VPT 2015, arXiv:1512.0221
Recommended from our members
MILO : a microarchitecture and logic optimizer
In this report we discuss strengths and weaknesses of logic synthesis systems and describe a system for microarchitectural and logic optimization. Our system uses a set of algorithms for synthesizing SSI/MSI macros from parameterized microarchitecture components. In addition, it uses rules for optimizing both at the microarchitecture and logic level. The system increases designer productivity and requires less design knowledge and experience from circuit engineers
Conditions for interoperability
Interoperability for information systems remains a challenge both at the semantic and organisational levels. The original three-level architecture for local databases needs to be replaced by a categorical four-level one based on concepts, constructions, schema types and data together with the mappings between them. Such an architecture provides natural closure as further levels are superfluous even in a global environment. The architecture is traversed by means of the Godement calculus: arrows may be composed at any level as well as across levles. The necessary and sufficient conditions for interoperability are satisfied by composable (formal) diagrams both for intension and extension in categories that are cartesian closed and locally cartesian closed. Methods like partial categories and sketches in schema design can benefit from Freyd’s punctured diagrams to identify precisely type-forcing natural transformations. Closure is better achieved in standard full categories. Global interoperability of extension can be achieved through semantic annotation but only if applied at run time
Modeling and Analyzing Adaptive User-Centric Systems in Real-Time Maude
Pervasive user-centric applications are systems which are meant to sense the
presence, mood, and intentions of users in order to optimize user comfort and
performance. Building such applications requires not only state-of-the art
techniques from artificial intelligence but also sound software engineering
methods for facilitating modular design, runtime adaptation and verification of
critical system requirements.
In this paper we focus on high-level design and analysis, and use the
algebraic rewriting language Real-Time Maude for specifying applications in a
real-time setting. We propose a generic component-based approach for modeling
pervasive user-centric systems and we show how to analyze and prove crucial
properties of the system architecture through model checking and simulation.
For proving time-dependent properties we use Metric Temporal Logic (MTL) and
present analysis algorithms for model checking two subclasses of MTL formulas:
time-bounded response and time-bounded safety MTL formulas. The underlying idea
is to extend the Real-Time Maude model with suitable clocks, to transform the
MTL formulas into LTL formulas over the extended specification, and then to use
the LTL model checker of Maude. It is shown that these analyses are sound and
complete for maximal time sampling. The approach is illustrated by a simple
adaptive advertising scenario in which an adaptive advertisement display can
react to actions of the users in front of the display.Comment: In Proceedings RTRTS 2010, arXiv:1009.398
Proving theorems by program transformation
In this paper we present an overview of the unfold/fold proof method, a method for proving theorems about programs, based on program transformation. As a metalanguage for specifying programs and program properties we adopt constraint logic programming (CLP), and we present a set of transformation rules (including the familiar unfolding and folding rules) which preserve the semantics of CLP programs. Then, we show how program transformation strategies can be used, similarly to theorem proving tactics, for guiding the application of the transformation rules and inferring the properties to be proved. We work out three examples: (i) the proof of predicate equivalences, applied to the verification of equality between CCS processes, (ii) the proof of first order formulas via an extension of the quantifier elimination method, and (iii) the proof of temporal properties of infinite state concurrent systems, by using a transformation strategy that performs program specialization
- …