23 research outputs found
Termination of Linear Programs with Nonlinear Constraints
Tiwari proved that termination of linear programs (loops with linear loop
conditions and updates) over the reals is decidable through Jordan forms and
eigenvectors computation. Braverman proved that it is also decidable over the
integers. In this paper, we consider the termination of loops with polynomial
loop conditions and linear updates over the reals and integers. First, we prove
that the termination of such loops over the integers is undecidable. Second,
with an assumption, we provide an complete algorithm to decide the termination
of a class of such programs over the reals. Our method is similar to that of
Tiwari in spirit but uses different techniques. Finally, we conjecture that the
termination of linear programs with polynomial loop conditions over the reals
is undecidable in general by %constructing a loop and reducing the problem to
another decision problem related to number theory and ergodic theory, which we
guess undecidable.Comment: 17pages, 0 figure
Complexity of Bradley-Manna-Sipma Lexicographic Ranking Functions
In this paper we turn the spotlight on a class of lexicographic ranking
functions introduced by Bradley, Manna and Sipma in a seminal CAV 2005 paper,
and establish for the first time the complexity of some problems involving the
inference of such functions for linear-constraint loops (without precondition).
We show that finding such a function, if one exists, can be done in polynomial
time in a way which is sound and complete when the variables range over the
rationals (or reals). We show that when variables range over the integers, the
problem is harder -- deciding the existence of a ranking function is
coNP-complete. Next, we study the problem of minimizing the number of
components in the ranking function (a.k.a. the dimension). This number is
interesting in contexts like computing iteration bounds and loop
parallelization. Surprisingly, and unlike the situation for some other classes
of lexicographic ranking functions, we find that even deciding whether a
two-component ranking function exists is harder than the unrestricted problem:
NP-complete over the rationals and -complete over the integers.Comment: Technical report for a corresponding CAV'15 pape
Distilling Programs to Prove Termination
The problem of determining whether or not any program terminates was shown to
be undecidable by Turing, but recent advances in the area have allowed this
information to be determined for a large class of programs. The classic method
for deciding whether a program terminates dates back to Turing himself and
involves finding a ranking function that maps a program state to a well-order,
and then proving that the result of this function decreases for every possible
program transition. More recent approaches to proving termination have involved
moving away from the search for a single ranking function and toward a search
for a set of ranking functions; this set is a choice of ranking functions and a
disjunctive termination argument is used. In this paper, we describe a new
technique for determining whether programs terminate. Our technique is applied
to the output of the distillation program transformation that converts programs
into a simplified form called distilled form. Programs in distilled form are
converted into a corresponding labelled transition system and termination can
be demonstrated by showing that all possible infinite traces through this
labelled transition system would result in an infinite descent of well-founded
data values. We demonstrate our technique on a number of examples, and compare
it to previous work.Comment: In Proceedings VPT/HCVS 2020, arXiv:2008.02483. This work owes a lot
to the input of Neil Jones, who provided many useful insights and ideas on
the subject matter presented her
Unrestricted Termination and Non-Termination Arguments for Bit-Vector Programs
Proving program termination is typically done by finding a well-founded
ranking function for the program states. Existing termination provers typically
find ranking functions using either linear algebra or templates. As such they
are often restricted to finding linear ranking functions over mathematical
integers. This class of functions is insufficient for proving termination of
many terminating programs, and furthermore a termination argument for a program
operating on mathematical integers does not always lead to a termination
argument for the same program operating on fixed-width machine integers. We
propose a termination analysis able to generate nonlinear, lexicographic
ranking functions and nonlinear recurrence sets that are correct for
fixed-width machine arithmetic and floating-point arithmetic Our technique is
based on a reduction from program \emph{termination} to second-order
\emph{satisfaction}. We provide formulations for termination and
non-termination in a fragment of second-order logic with restricted
quantification which is decidable over finite domains. The resulted technique
is a sound and complete analysis for the termination of finite-state programs
with fixed-width integers and IEEE floating-point arithmetic
Automated Termination Analysis of Java Bytecode by Term Rewriting
We present an automated approach to prove termination of Java Bytecode (JBC) programs by automatically transforming them to term rewrite systems (TRSs). In this way, the numerous techniques and tools developed for TRS termination can now be used for imperative object-oriented languages like Java, which can be compiled into JBC
Detecting and escaping infinite loops with jolt
25th European Conference, Lancaster, Uk, July 25-29, 2011 ProceedingsInfinite loops can make applications unresponsive. Potential problems include lost work or output, denied access to application functionality, and a lack of responses to urgent events. We present Jolt, a novel system for dynamically detecting and escaping infinite loops. At the user’s request, Jolt attaches to an application to monitor its progress. Specifically, Jolt records the program state at the start of each loop iteration. If two consecutive loop iterations produce the same state, Jolt reports to the user that the application is in an infinite loop. At the user’s option, Jolt can then transfer control to a statement following the loop, thereby allowing the application to escape the infinite loop and ideally continue its productive execution. The immediate goal is to enable the application to execute long enough to save any pending work, finish any in-progress computations, or respond to any urgent events.
We evaluated Jolt by applying it to detect and escape eight infinite loops in five benchmark applications. Jolt was able to detect seven of the eight infinite loops (the eighth changes the state on every iteration). We also evaluated the effect of escaping an infinite loop as an alternative to terminating the application. In all of our benchmark applications, escaping an infinite loop produced a more useful output than terminating the application. Finally, we evaluated how well escaping from an infinite loop approximated the correction that the developers later made to the application. For two out of our eight loops, escaping the infinite loop produced the same output as the corrected version of the application
Program Verification by Using DISCOVERER
Recent advances in program verification indicate that various verification problems can be reduced to semi-algebraic system (SAS for short) solving. An SAS consists of polynomial equations and polynomial inequalities. Algorithms for quantifier elimination of real closed fields are the general method for those problems. But the general method usually has low efficiency for specific problems. To overcome the bottleneck of program verification with a symbolic approach, one has to combine special techniques with the general method. Based on the work of complete discrimination systems of polynomials [33,31], we invented new theories and algorithms [32,30,35] for SAS solving and partly implemented them as a real symbolic computation tool in Maple named DISCOVERER. In this paper, we first summarize the results that we have done so far both on SAS-solving and program verification with DISCOVERER, and then discuss the future work in this direction, including SAS-solving itself, termination analysis and invariant generation of programs, and reachability computation of hybrid systems etc. ? IFIP International Federation for Information Processing 2008.EI