Results 1  10
of
22
Termination Analysis of Java Bytecode
"... The state of the art in termination analysis includes advanced techniques developed for logic and functional programming [12, 4, 9, 11, 10] and imperative languages [2, 5, 8, 6, 10], as well as for term rewriting systems [10]. In [6, 5] tools for proving termination of large industrial code are pres ..."
Abstract

Cited by 43 (18 self)
 Add to MetaCart
(Show Context)
The state of the art in termination analysis includes advanced techniques developed for logic and functional programming [12, 4, 9, 11, 10] and imperative languages [2, 5, 8, 6, 10], as well as for term rewriting systems [10]. In [6, 5] tools for proving termination of large industrial code are presented. However, termination of lowlevel languages, such as Java bytecode, has received little
Automatic Numeric Abstractions for HeapManipulating Programs
, 2010
"... We present a logic for relating heapmanipulating programs to numeric abstractions. These numeric abstractions are expressed as simple imperative programs over integer variables and have the property that termination and safety of the numeric program ensures termination and safety of the original, h ..."
Abstract

Cited by 31 (2 self)
 Add to MetaCart
(Show Context)
We present a logic for relating heapmanipulating programs to numeric abstractions. These numeric abstractions are expressed as simple imperative programs over integer variables and have the property that termination and safety of the numeric program ensures termination and safety of the original, heapmanipulating program. We have implemented an automated version of this abstraction process and present experimental results for programs involving a variety of data structures.
Complete sequent calculi for induction and infinite descent
 Proceedings of LICS22
, 2007
"... This paper compares two different styles of reasoning with inductively defined predicates, each style being encapsulated by a corresponding sequent calculus proof system. The first system supports traditional proof by induction, with induction rules formulated as sequent rules for introducing induct ..."
Abstract

Cited by 25 (8 self)
 Add to MetaCart
(Show Context)
This paper compares two different styles of reasoning with inductively defined predicates, each style being encapsulated by a corresponding sequent calculus proof system. The first system supports traditional proof by induction, with induction rules formulated as sequent rules for introducing inductively defined predicates on the left of sequents. We show this system to be cutfree complete with respect to a natural class of Henkin models; the eliminability of cut follows as a corollary. The second system uses infinite (nonwellfounded) proofs to represent arguments by infinite descent. In this system, the left rules for inductively defined predicates are simple casesplit rules, and an infinitary, global condition on proof trees is required to ensure soundness. We show this system to be cutfree complete with respect to standard models, and again infer the eliminability of cut. The second infinitary system is unsuitable for formal reasoning. However, it has a natural restriction to proofs given by regular trees, i.e. to those proofs representable by finite graphs. This restricted “cyclic ” system subsumes the first system for proof by induction. We conjecture that the two systems are in fact equivalent, i.e., that proof by induction is equivalent to regular proof by infinite descent.
Synthesizing data structure manipulations from storyboards
 In Proceedings of the Symposium on the Foundations of Software Engineering
, 2011
"... We present the Storyboard Programming framework, a new synthesis system designed to help programmers write imperative lowlevel datastructure manipulations. The goal of this system is to bridge the gap between the “boxesandarrows”diagrams that programmers often use to think about datastructure ..."
Abstract

Cited by 14 (5 self)
 Add to MetaCart
(Show Context)
We present the Storyboard Programming framework, a new synthesis system designed to help programmers write imperative lowlevel datastructure manipulations. The goal of this system is to bridge the gap between the “boxesandarrows”diagrams that programmers often use to think about datastructure manipulation algorithms and the lowlevel imperative code that implements them. The system takes as input a set of partial inputoutput examples, as well as a description of the highlevel structure of the desired solution. From this information, it is able to synthesize lowlevel imperative implementations in a matter of minutes. The framework is based on a new approach for combining constraintbased synthesis and abstractinterpretationbased shape analysis. The approach works by encoding both the synthesis and the abstract interpretation problem as a constraint satisfaction problem whose solution defines the desired lowlevel implementation. We have used the framework to synthesize several datastructure manipulations involving linked lists and binary search trees, as well as an insertion operation into an And Inverter Graph.
A Termination Analyser for Java Bytecode Based on PathLength
"... It is important to prove that supposedly terminating programs actually terminate, particularly if those programs must be run on critical systems or downloaded into a client such as a mobile phone. Although termination of computer programs is generally undecidable, it is possible and useful to prove ..."
Abstract

Cited by 13 (3 self)
 Add to MetaCart
It is important to prove that supposedly terminating programs actually terminate, particularly if those programs must be run on critical systems or downloaded into a client such as a mobile phone. Although termination of computer programs is generally undecidable, it is possible and useful to prove termination of a large, nontrivial subset of the terminating programs. In this paper we present our termination analyser for sequential Java bytecode, based on a program property called pathlength. We describe the analyses which are needed before the pathlength can be computed, such as sharing, cyclicity and aliasing. Then we formally define the pathlength analysis and prove it correct w.r.t. a reference denotational semantics of the bytecode. We show that a constraint logic program PCLP can be built from the result of the pathlength analysis of a Java bytecode program P and formally prove that if PCLP terminates then also P terminates. Hence a termination prover for constraint logic programs can be applied to prove the termination of P. We conclude with some discussion of the possibilities and limitations of our approach. Ours is the first existing termination analyser for Java bytecode dealing with generic data structures dynamically allocated on the heap and which does not require any help or annotation on the part of the user.
A generic cyclic theorem prover
 In APLAS’12, volume 7705 of LNCS
, 2012
"... Abstract. We describe the design and implementation of an automated theorem prover realising a fully general notion of cyclic proof. Our tool, called Cyclist, is able to construct proofs obeying a very general cycle scheme in which leaves may be linked to any other matching node in the proof, and to ..."
Abstract

Cited by 13 (7 self)
 Add to MetaCart
(Show Context)
Abstract. We describe the design and implementation of an automated theorem prover realising a fully general notion of cyclic proof. Our tool, called Cyclist, is able to construct proofs obeying a very general cycle scheme in which leaves may be linked to any other matching node in the proof, and to verify the general, global infinitary condition on such proof objects ensuring their soundness. Cyclist is based on a new, generic theory of cyclic proofs that can be instantiated to a wide variety of logics. We have developed three such concrete instantiations, based on: (a) firstorder logic with inductive definitions; (b) entailments of pure separation logic; and (c) Hoarestyle termination proofs for pointer programs. Experiments run on these instantiations indicate that Cyclist offers significant potential as a future platform for inductive theorem proving. 1
Amortised resource analysis with separation logic
 In European Symposium on Programming (ESOP
, 2010
"... Abstract. Typebased amortised resource analysis following Hofmann and Jost—where resources are associated with individual elements of data structures and doled out to the programmer under a linear typing discipline—have been successful in providing concrete resource bounds for functional programs, ..."
Abstract

Cited by 12 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Typebased amortised resource analysis following Hofmann and Jost—where resources are associated with individual elements of data structures and doled out to the programmer under a linear typing discipline—have been successful in providing concrete resource bounds for functional programs, with good support for inference. In this work we translate the idea of amortised resource analysis to imperative languages by embedding a logic of resources, based on Bunched Implications, within Separation Logic. The Separation Logic component allows us to assert the presence and shape of mutable data structures on the heap, while the resource component allows us to state the resources associated with each member of the structure. We present the logic on a small imperative language with procedures and mutable heap, based on Java bytecode. We have formalised the logic within the Coq proof assistant and extracted a certified verification condition generator. We demonstrate the logic on some examples, including proving termination of inplace list reversal on lists with cyclic tails. 1
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.
Selfstabilizing java
 In PLDI
, 2012
"... Selfstabilizing programs automatically recover from state corruption caused by software bugs and other sources to reach the correct state. A number of applications are inherently selfstabilizing— such programs typically overwrite all nonconstant data with new input data. We present a type system ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
Selfstabilizing programs automatically recover from state corruption caused by software bugs and other sources to reach the correct state. A number of applications are inherently selfstabilizing— such programs typically overwrite all nonconstant data with new input data. We present a type system and static analyses that together check whether a program is selfstabilizing. We combine this with a code generation strategy that ensures that a program continues executing long enough to selfstabilize. Our experience using SJava indicates that (1) SJava annotations are easy to write once one understands a program and (2) SJava successfully checked that several benchmarks were selfstabilizing.
Automated cyclic entailment proofs in separation logic
 In CADE’11
, 2011
"... Abstract. We present a general automated proof procedure, based upon cyclic proof, for inductive entailments in separation logic. Our procedure has been implemented via a deep embedding of cyclic proofs in the HOL Light theorem prover. Experiments show that our mechanism is able to prove a number of ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
Abstract. We present a general automated proof procedure, based upon cyclic proof, for inductive entailments in separation logic. Our procedure has been implemented via a deep embedding of cyclic proofs in the HOL Light theorem prover. Experiments show that our mechanism is able to prove a number of nontrivial entailments involving inductive predicates. 1