Results 1  10
of
12
Automated Termination Proofs for Java Programs with Cyclic Data
, 2012
"... In earlier work, we developed a technique to prove termination of Java programs automatically: first, Java programs are automatically transformed to term rewrite systems (TRSs) and then, existing methods and tools are used to prove termination of the resulting TRSs. In this paper, we extend our tech ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
(Show Context)
In earlier work, we developed a technique to prove termination of Java programs automatically: first, Java programs are automatically transformed to term rewrite systems (TRSs) and then, existing methods and tools are used to prove termination of the resulting TRSs. In this paper, we extend our technique in order to prove termination of algorithms on cyclic data such as cyclic lists or graphs automatically. We implemented our technique in the tool AProVE and performed extensive experiments to evaluate its practical applicability.
Proving NonLooping NonTermination Automatically ⋆
"... Abstract. We introduce a technique to prove nontermination of term rewrite systems automatically. Our technique improves over previous approaches substantially, as it can also detect nonlooping nontermination. 1 ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
(Show Context)
Abstract. We introduce a technique to prove nontermination of term rewrite systems automatically. Our technique improves over previous approaches substantially, as it can also detect nonlooping nontermination. 1
Symbolic Evaluation Graphs and Term Rewriting  A General Methodology for Analyzing Logic Programs
, 2012
"... There exist many powerful techniques to analyze termination and complexity of term rewrite systems (TRSs). Our goal is to use these techniques for the analysis of other programming languages as well. For instance, approaches to prove termination of definite logic programs by a transformation to TRSs ..."
Abstract

Cited by 6 (4 self)
 Add to MetaCart
There exist many powerful techniques to analyze termination and complexity of term rewrite systems (TRSs). Our goal is to use these techniques for the analysis of other programming languages as well. For instance, approaches to prove termination of definite logic programs by a transformation to TRSs have been studied for decades. However, a challenge is to handle languages with more complex evaluation strategies (such as Prolog, where predicates like the cut influence the control flow). In this paper, we present a general methodology for the analysis of such programs. Here, the logic program is first transformed into a symbolic evaluation graph which represents all possible evaluations in a finite way. Afterwards, different analyses can be performed on these graphs. In particular, one can generate TRSs from such graphs and apply existing tools for termination or complexity analysis of TRSs to infer information on the termination or complexity of the original logic program.
R.: Proving termination of programs automatically with aprove
 In: Proceedings of IJCAR 2014
, 2014
"... Abstract. AProVE is a system for automatic termination and complexity proofs of Java, C, Haskell, Prolog, and term rewrite systems (TRSs). To analyze programs in highlevel languages, AProVE automatically converts them to TRSs. Then, a wide range of techniques is employed to prove termination and t ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
(Show Context)
Abstract. AProVE is a system for automatic termination and complexity proofs of Java, C, Haskell, Prolog, and term rewrite systems (TRSs). To analyze programs in highlevel languages, AProVE automatically converts them to TRSs. Then, a wide range of techniques is employed to prove termination and to infer complexity bounds for the resulting TRSs. The generated proofs can be exported to check their correctness using automatic certifiers. For use in software construction, we present an AProVE plugin for the popular Eclipse software development environment.
Proving Nontermination Using MaxSMT
"... Abstract. We show how MaxSMTbased invariant generation can be exploited for proving nontermination of programs. The construction of the proof of nontermination is guided by the generation of quasiinvariants – properties such that if they hold at a location during execution once, then they will c ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
(Show Context)
Abstract. We show how MaxSMTbased invariant generation can be exploited for proving nontermination of programs. The construction of the proof of nontermination is guided by the generation of quasiinvariants – properties such that if they hold at a location during execution once, then they will continue to hold at that location from then onwards. The check that quasiinvariants can indeed be reached is then performed separately. Our technique considers strongly connected subgraphs of a program’s control flow graph for analysis and thus produces more generic witnesses of nontermination than existing methods. Moreover, it can handle programs with unbounded nondeterminism and is more likely to converge than previous approaches. 1
Predicate Abstraction and CEGAR for Disproving Termination of Higherorder Functional Programs
"... Abstract. We propose an automated method for disproving termination of higherorder functional programs. Our method combines higherorder model checking with predicate abstraction and CEGAR. Our predicate abstraction is novel in that it computes a mixture of under and overapproximations. For non ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
(Show Context)
Abstract. We propose an automated method for disproving termination of higherorder functional programs. Our method combines higherorder model checking with predicate abstraction and CEGAR. Our predicate abstraction is novel in that it computes a mixture of under and overapproximations. For nondeterminism of a source program (such as random number generation), we apply underapproximation to generate a subset of the actual branches, and check that some of the branches in the abstract program is nonterminating. For operations on infinite data domains (such as integers), we apply overapproximation to generate a superset of the actual branches, and check that every branch is nonterminating. Thus, disproving nontermination reduces to the problem of checking a certain branching property of the abstract program, which can be solved by higherorder model checking. We have implemented a prototype nontermination prover based on our method and have confirmed the effectiveness of the proposed approach through experiments. 1
CLAPP: Characterizing Loops in Android Applications
"... When performing program analysis, loops are one of the most important aspects that needs to be taken into account. In the past, many approaches have been proposed to analyze loops to perform different tasks, ranging from compiler optimizations to WorstCase Execution Time (WCET) analysis. While thes ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
When performing program analysis, loops are one of the most important aspects that needs to be taken into account. In the past, many approaches have been proposed to analyze loops to perform different tasks, ranging from compiler optimizations to WorstCase Execution Time (WCET) analysis. While these approaches are powerful, they focus on tackling very specic categories of loops and known loop patterns, such as the ones for which the number of iterations can be statically determined. In this work, we developed a static analysis framework to characterize and analyze generic loops, without relying on techniques based on pattern matching. For this work, we focus on the Android platform, and we implemented a prototype, called Clapp, that we used to perform the rst largescale empirical study of the usage of loops in Android applications. In particular, we used our tool to analyze a total of 4,110,510 loops found in 11,823 Android applications. As part of our evaluation, we provide the detailed results of our empirical study, we show how our analysis was able to determine that the execution of 63.28 % of the loops is bounded, and we discuss several interesting insights related to the performance issues and security aspects associated with loops.
2 Automated Detection of NonTermination and NullPointerExceptions for Java Bytecode ⋆
, 2011
"... Abstract. Recently, we developed an approach for automated termination proofs of Java Bytecode (JBC), which is based on constructing and analyzing termination graphs. These graphs represent all possible program executions in afiniteway. Inthis paper, we showthat this approach can also be used to det ..."
Abstract
 Add to MetaCart
Abstract. Recently, we developed an approach for automated termination proofs of Java Bytecode (JBC), which is based on constructing and analyzing termination graphs. These graphs represent all possible program executions in afiniteway. Inthis paper, we showthat this approach can also be used to detect nontermination or NullPointerExceptions. Ourapproach automatically generates witnesses, i.e., calling theprogram with these witness arguments indeed leads to nontermination resp. to a NullPointerException. Thus, we never obtain “false positives”. We implemented our results in the termination prover AProVE and provide experimental evidence for the power of our approach. 1
Automated Detection of NonTermination in Java Programs Seminar: Satisfiability Checking
"... The automatic detection of nontermination bugs in programs is an important research topic, especially with regard to safetycritical realtime systems (e.g. software in cars or planes), where nonterminating behaviour may lead to severe consequences. Moreover, in case of the existence of such a bug ..."
Abstract
 Add to MetaCart
(Show Context)
The automatic detection of nontermination bugs in programs is an important research topic, especially with regard to safetycritical realtime systems (e.g. software in cars or planes), where nonterminating behaviour may lead to severe consequences. Moreover, in case of the existence of such a bug, for debugging purposes one is interested in the program input that causes it. An approach to this problem (for Java programs) has been developed by the LuFGI2 group. 1
A Devil’s Advocate against Termination of Direct Recursion
"... www.informatik.uniulm.de/pm/mitarbeiter/fruehwirth/ A devil’s advocate is one who argues against a claim, not as a committed opponent but in order to determine the validity of the claim. We are interested in a devil’s advocate that argues against termination of a program. He does so by producing ..."
Abstract
 Add to MetaCart
(Show Context)
www.informatik.uniulm.de/pm/mitarbeiter/fruehwirth/ A devil’s advocate is one who argues against a claim, not as a committed opponent but in order to determine the validity of the claim. We are interested in a devil’s advocate that argues against termination of a program. He does so by producing a maleficent program that can cause the nontermination of the original program. By inspecting and running the malicious program, one may gain insight into the potential reasons for nontermination and produce counterexamples for termination. We introduce our method in the concurrent programming language Constraint Handling Rules (CHR). Like in other declarative languages, nontermination occurs through unbounded recursion. Given a selfrecursive rule, we automatically generate one or more devil’s rules from it. The construction of the devil’s rules is straightforward and involves no guessing. The devil’s rules can be simple. For example, they are nonrecursive for rules with single recursion. We show that the devil’s rules are maximally vicious in the following sense: For any program that contains the selfrecursive rule and for any infinite computation through that rule in that program, there is a corresponding infinite computation with the recursive rule and the devil’s rules alone. In that case, the malicious rules serve as a finite witness for nontermination. On the other hand, if the devil’s rules do not exhibit an infinite computation, the recursive rule is unconditionally terminating. We also identify cases where the static analysis of the devil’s rule decides termination or nontermination of the recursive rule.