831 research outputs found
Ranking Functions for Size-Change Termination II
Size-Change Termination is an increasingly-popular technique for verifying
program termination. These termination proofs are deduced from an abstract
representation of the program in the form of "size-change graphs".
We present algorithms that, for certain classes of size-change graphs, deduce
a global ranking function: an expression that ranks program states, and
decreases on every transition. A ranking function serves as a witness for a
termination proof, and is therefore interesting for program certification. The
particular form of the ranking expressions that represent SCT termination
proofs sheds light on the scope of the proof method. The complexity of the
expressions is also interesting, both practicaly and theoretically.
While deducing ranking functions from size-change graphs has already been
shown possible, the constructions in this paper are simpler and more
transparent than previously known. They improve the upper bound on the size of
the ranking expression from triply exponential down to singly exponential (for
certain classes of instances). We claim that this result is, in some sense,
optimal. To this end, we introduce a framework for lower bounds on the
complexity of ranking expressions and prove exponential lower bounds.Comment: 29 pages
SAT-Based Termination Analysis Using Monotonicity Constraints over the Integers
We describe an algorithm for proving termination of programs abstracted to
systems of monotonicity constraints in the integer domain. Monotonicity
constraints are a non-trivial extension of the well-known size-change
termination method. While deciding termination for systems of monotonicity
constraints is PSPACE complete, we focus on a well-defined and significant
subset, which we call MCNP, designed to be amenable to a SAT-based solution.
Our technique is based on the search for a special type of ranking function
defined in terms of bounded differences between multisets of integer values. We
describe the application of our approach as the back-end for the termination
analysis of Java Bytecode (JBC). At the front-end, systems of monotonicity
constraints are obtained by abstracting information, using two different
termination analyzers: AProVE and COSTA. Preliminary results reveal that our
approach provides a good trade-off between precision and cost of analysis
On Decidable Growth-Rate Properties of Imperative Programs
In 2008, Ben-Amram, Jones and Kristiansen showed that for a simple "core"
programming language - an imperative language with bounded loops, and
arithmetics limited to addition and multiplication - it was possible to decide
precisely whether a program had certain growth-rate properties, namely
polynomial (or linear) bounds on computed values, or on the running time.
This work emphasized the role of the core language in mitigating the
notorious undecidability of program properties, so that one deals with
decidable problems.
A natural and intriguing problem was whether more elements can be added to
the core language, improving its utility, while keeping the growth-rate
properties decidable. In particular, the method presented could not handle a
command that resets a variable to zero. This paper shows how to handle resets.
The analysis is given in a logical style (proof rules), and its complexity is
shown to be PSPACE-complete (in contrast, without resets, the problem was
PTIME). The analysis algorithm evolved from the previous solution in an
interesting way: focus was shifted from proving a bound to disproving it, and
the algorithm works top-down rather than bottom-up
Program Synthesis for Program Analysis
In this article, we propose a unified framework for designing static analysers based on program synthesis. For this purpose, we identify a fragment of second-order logic with restricted quantification that is expressive enough to model numerous static analysis problems (e.g., safety proving, bug finding, termination and non-termination proving, refactoring). As our focus is on programs that use bit-vectors, we build a decision procedure for this fragment over finite domains in the form of a program synthesiser. We provide instantiations of our framework for solving a diverse range of program verification tasks such as termination, non-termination, safety and bug finding, superoptimisation, and refactoring. Our experimental results show that our program synthesiser compares positively with specialised tools in each area as well as with general-purpose synthesisers
Analyzing runtime and size complexity of integer programs
We present a modular approach to automatic complexity analysis of integer programs. Based on a novel alternation between finding symbolic time bounds for program parts and using these to infer bounds on the absolute values of program variables, we can restrict each analysis step to a small part of the program while maintaining a high level of precision. The bounds computed by our method are polynomial or exponential expressions that depend on the absolute values of input parameters.
We show how to extend our approach to arbitrary cost measures, allowing to use our technique to find upper bounds for other expended resources, such as network requests or memory consumption. Our contributions are implemented in the open source tool KoAT, and extensive experiments show the performance and power of our implementation in comparison with other tools
Bounding the Computational Complexity of Flowchart Programs with Multi-dimensional Rankings
Proving the termination of a flowchart program can be done by exhibiting a ranking function, i.e., a function from the program states to a well-founded set, which strictly decreases at each program step. A standard method to automatically generate such a function is to compute invariants for each program point and to search for a ranking in a restricted class of functions that can be handled with linear programming techniques. Our first contribution is to propose an efficient algorithm to compute ranking functions: It can handle flowcharts of arbitrary structure, the class of candidate rankings it explores is larger, and our method, although greedy, is provably complete. Our second contribution is to show how to use the ranking functions we generate to get upper bounds for the computational complexity (number of transitions) of the source program, again for flowcharts of arbitrary structure. This estimate is a polynomial, which means that we can handle programs with more than linear complexity. We applied the method on a collection of test cases from the literature. We also point out important extensions, mainly to do with the scalability of the algorithm and, in particular, the integration of techniques based on cutpoints
Extending Modular Semantics for Bipolar Weighted Argumentation (Technical Report)
Weighted bipolar argumentation frameworks offer a tool for decision support
and social media analysis. Arguments are evaluated by an iterative procedure
that takes initial weights and attack and support relations into account. Until
recently, convergence of these iterative procedures was not very well
understood in cyclic graphs. Mossakowski and Neuhaus recently introduced a
unification of different approaches and proved first convergence and divergence
results. We build up on this work, simplify and generalize convergence results
and complement them with runtime guarantees. As it turns out, there is a
tradeoff between semantics' convergence guarantees and their ability to move
strength values away from the initial weights. We demonstrate that divergence
problems can be avoided without this tradeoff by continuizing semantics.
Semantically, we extend the framework with a Duality property that assures a
symmetric impact of attack and support relations. We also present a Java
implementation of modular semantics and explain the practical usefulness of the
theoretical ideas
A Simple Deterministic Distributed MST Algorithm, with Near-Optimal Time and Message Complexities
Distributed minimum spanning tree (MST) problem is one of the most central
and fundamental problems in distributed graph algorithms. Garay et al.
\cite{GKP98,KP98} devised an algorithm with running time , where is the hop-diameter of the input -vertex -edge
graph, and with message complexity . Peleg and Rubinovich
\cite{PR99} showed that the running time of the algorithm of \cite{KP98} is
essentially tight, and asked if one can achieve near-optimal running time
**together with near-optimal message complexity**.
In a recent breakthrough, Pandurangan et al. \cite{PRS16} answered this
question in the affirmative, and devised a **randomized** algorithm with time
and message complexity . They asked if
such a simultaneous time- and message-optimality can be achieved by a
**deterministic** algorithm.
In this paper, building upon the work of \cite{PRS16}, we answer this
question in the affirmative, and devise a **deterministic** algorithm that
computes MST in time , using messages. The polylogarithmic factors in the time
and message complexities of our algorithm are significantly smaller than the
respective factors in the result of \cite{PRS16}. Also, our algorithm and its
analysis are very **simple** and self-contained, as opposed to rather
complicated previous sublinear-time algorithms \cite{GKP98,KP98,E04b,PRS16}
- ā¦