660 research outputs found
Fixpoint Games on Continuous Lattices
Many analysis and verifications tasks, such as static program analyses and
model-checking for temporal logics reduce to the solution of systems of
equations over suitable lattices. Inspired by recent work on lattice-theoretic
progress measures, we develop a game-theoretical approach to the solution of
systems of monotone equations over lattices, where for each single equation
either the least or greatest solution is taken. A simple parity game, referred
to as fixpoint game, is defined that provides a correct and complete
characterisation of the solution of equation systems over continuous lattices,
a quite general class of lattices widely used in semantics. For powerset
lattices the fixpoint game is intimately connected with classical parity games
for -calculus model-checking, whose solution can exploit as a key tool
Jurdzi\'nski's small progress measures. We show how the notion of progress
measure can be naturally generalised to fixpoint games over continuous lattices
and we prove the existence of small progress measures. Our results lead to a
constructive formulation of progress measures as (least) fixpoints. We refine
this characterisation by introducing the notion of selection that allows one to
constrain the plays in the parity game, enabling an effective (and possibly
efficient) solution of the game, and thus of the associated verification
problem. We also propose a logic for specifying the moves of the existential
player that can be used to systematically derive simplified equations for
efficiently computing progress measures. We discuss potential applications to
the model-checking of latticed -calculi and to the solution of fixpoint
equations systems over the reals
A Backward Analysis for Constraint Logic Programs
One recurring problem in program development is that of understanding how to
re-use code developed by a third party. In the context of (constraint) logic
programming, part of this problem reduces to figuring out how to query a
program. If the logic program does not come with any documentation, then the
programmer is forced to either experiment with queries in an ad hoc fashion or
trace the control-flow of the program (backward) to infer the modes in which a
predicate must be called so as to avoid an instantiation error. This paper
presents an abstract interpretation scheme that automates the latter technique.
The analysis presented in this paper can infer moding properties which if
satisfied by the initial query, come with the guarantee that the program and
query can never generate any moding or instantiation errors. Other applications
of the analysis are discussed. The paper explains how abstract domains with
certain computational properties (they condense) can be used to trace
control-flow backward (right-to-left) to infer useful properties of initial
queries. A correctness argument is presented and an implementation is reported.Comment: 32 page
Programs as Diagrams: From Categorical Computability to Computable Categories
This is a draft of the textbook/monograph that presents computability theory
using string diagrams. The introductory chapters have been taught as graduate
and undergraduate courses and evolved through 8 years of lecture notes. The
later chapters contain new ideas and results about categorical computability
and some first steps into computable category theory. The underlying
categorical view of computation is based on monoidal categories with program
evaluators, called *monoidal computers*. This categorical structure can be
viewed as a single-instruction diagrammatic programming language called Run,
whose only instruction is called RUN. This version: improved text, moved the
final chapter to the next volume. (The final version will continue lots of
exercises and workouts, but already this version has severely degraded graphics
to meet the size bounds.)Comment: 150 pages, 81 figure
An efficient, parametric fixpoint algorithm for analysis of java bytecode
Abstract interpretation has been widely used for the analysis of object-oriented languages and, in particular, Java source and bytecode. However, while most existing work deals with the problem of flnding expressive abstract domains that track accurately the characteristics of a particular concrete property, the underlying flxpoint algorithms have received comparatively less attention. In fact, many existing (abstract interpretation based—) flxpoint algorithms rely on relatively inefHcient techniques for solving inter-procedural caligraphs or are speciflc and tied to particular analyses. We also argüe that the design of an efficient fixpoint algorithm is pivotal to supporting the analysis of large programs. In this paper we introduce a novel algorithm for analysis of Java bytecode which includes a number of optimizations in order to reduce the number of iterations. The algorithm is parametric -in the sense that it is independent of the abstract domain used and it can be applied to different domains as "plug-ins"-, multivariant, and flow-sensitive. Also, is based on a program transformation, prior to the analysis, that results in a highly uniform representation of all the features in the language and therefore simplifies analysis. Detailed descriptions of decompilation solutions are given and discussed with an example. We also provide some performance data from a preliminary implementation of the analysis
On the practicality of global flow analysis of logic programs
This paper addresses the issue of the practicality of global flow analysis in logic program compilation, in terms of both speed and precision of analysis. It discusses design and implementation aspects of two practical abstract interpretation-based flow analysis systems: MA3, the MOO Andparallel Analyzer and Annotator; and Ms, an experimental mode inference system developed for SB-Prolog. The paper also provides performance data obtained from these implementations. Based on these results, it is concluded that the overhead of global flow analysis is not prohibitive, while the results of analysis can be quite precise and useful
- …