Results 1  10
of
109
A NATURAL AXIOMATIZATION OF COMPUTABILITY AND PROOF OF CHURCH’S THESIS
"... Abstract. Church’s Thesis asserts that the only numeric functions that can be calculated by effective means are the recursive ones, which are the same, extensionally, as the Turingcomputable numeric functions. The Abstract State Machine Theorem states that every classical algorithm is behaviorally e ..."
Abstract

Cited by 32 (15 self)
 Add to MetaCart
(Show Context)
Abstract. Church’s Thesis asserts that the only numeric functions that can be calculated by effective means are the recursive ones, which are the same, extensionally, as the Turingcomputable numeric functions. The Abstract State Machine Theorem states that every classical algorithm is behaviorally equivalent to an abstract state machine. This theorem presupposes three natural postulates about algorithmic computation. Here, we show that augmenting those postulates with an additional requirement regarding basic operations gives a natural axiomatization of computability and a proof of Church’s Thesis, as Gödel and others suggested may be possible. In a similar way, but with a different set of basic operations, one can prove Turing’s Thesis, characterizing the effective string functions, and—in particular—the effectivelycomputable functions on string representations of numbers.
The ASM ground model method as a foundation of requirements engineering
 Verification: Theory and Practice, volume 2772 of LNCS
, 2003
"... Abstract. Building ground models is one of the three constituents of the engineering method for computerbased systems which is known as Abstract State Machine (ASM) method [16]. In this note we characterize ground models, whose epistemological role for a foundation of system design resembles the on ..."
Abstract

Cited by 29 (9 self)
 Add to MetaCart
Abstract. Building ground models is one of the three constituents of the engineering method for computerbased systems which is known as Abstract State Machine (ASM) method [16]. In this note we characterize ground models, whose epistemological role for a foundation of system design resembles the one Aristotle assigned to axioms to ground science in reality, avoiding infinite regress. We explain how ASM ground models help to resolve two major problems of requirements engineering, providing means a) to obtain for complex computerbased systems an adequate understanding by humans, and b) to cope with everchanging requirements by faithfully capturing and tracing them via welldocumented modeling–for–change. We point out that via an appropriate refinement method one can relate ground models to executable code. 1 IINTRODUCTION In a recent paper [6] Daniel Berry identifies requirements engineering as the main source for “the inevitable pain of software development”, explaining “why there
Modularizing Theorems for Software Product Lines
"... A goal of software product lines is the economical synthesis of programs in a family of programs. In this paper, we explain how theorems about program properties can be integrated into featurebased development of software product lines. As a case study, we analyze an existing Java/JVM compilation c ..."
Abstract

Cited by 20 (4 self)
 Add to MetaCart
(Show Context)
A goal of software product lines is the economical synthesis of programs in a family of programs. In this paper, we explain how theorems about program properties can be integrated into featurebased development of software product lines. As a case study, we analyze an existing Java/JVM compilation correctness proof for defining, interpreting, compiling, and executing bytecode for the Java language. We explain how features modularize both programs and theorems. By composing features, the source code and theorems for a program are synthesized. Generated theorems may then be certified manually or automatically using a proof checker, opening a new line of research in verification. 1
CoreASM: An extensible ASM execution engine
 PROC. OF THE 12TH INT’L WORKSHOP ON ABSTRACT STATE MACHINES
, 2005
"... In this paper we introduce a new research effort in making abstract state machines executable. The aim is to specify and implement an execution engine for a language that is as close as possible to the mathematical definition of pure ASM. The paper presents the general architecture of the engine, to ..."
Abstract

Cited by 20 (6 self)
 Add to MetaCart
In this paper we introduce a new research effort in making abstract state machines executable. The aim is to specify and implement an execution engine for a language that is as close as possible to the mathematical definition of pure ASM. The paper presents the general architecture of the engine, together with a highlevel description of the extensibility mechanisms that are used by the engine to accommodate arbitrary backgrounds, scheduling policies, and new rule forms.
Simple verification technique for complex Java bytecode subroutines
 In Proc. 4th ECOOP Workshop on Formal Techniques for Javalike Programs
, 2002
"... Abstract. Java is normally compiled to bytecode, which is verified and then executed by the Java Virtual Machine. Bytecode produced via compilation must pass verification. The main cause of complexity for bytecode verification is subroutines, used by compilers to generate more compact code. The tech ..."
Abstract

Cited by 17 (2 self)
 Add to MetaCart
Abstract. Java is normally compiled to bytecode, which is verified and then executed by the Java Virtual Machine. Bytecode produced via compilation must pass verification. The main cause of complexity for bytecode verification is subroutines, used by compilers to generate more compact code. The techniques to verify subroutines proposed in the literature reject certain programs produced by mundane compilers or are otherwise difficult to realize within an implementation of the Java Virtual Machine. This paper presents a novel technique which is very simple to understand, implement, and prove sound. It is also very powerful: the set of accepted programs has a simple characterization which most likely includes all code generable by current compilers and which enables future compilers to make more extensive use of subroutines. 1 Java Bytecode Java [2, 11] is normally compiled to a platformindependent bytecode language, which is executed by the Java Virtual Machine (JVM) [18]. This bytecode language features intramethod subroutines, used by Java compilers to generate more compact code [18, Sect. 7.13].
Java Program Verification via a JVM Deep Embedding in ACL2
 Theorem Proving in Higher Order Logics (TPHOLS ’04
, 2004
"... In this paper, we show that one can "deepembed" the Java bytecode language, a fairly complicated language with a rich semantics, into the first order logic of ACL2 by modeling a realistic JVM. We show that with proper support from a semiautomatic theorem prover in that logic, one can rea ..."
Abstract

Cited by 15 (4 self)
 Add to MetaCart
(Show Context)
In this paper, we show that one can "deepembed" the Java bytecode language, a fairly complicated language with a rich semantics, into the first order logic of ACL2 by modeling a realistic JVM. We show that with proper support from a semiautomatic theorem prover in that logic, one can reason about the correctness of Java programs. This reasoning can be done in a direct and intuitive way without incurring the extra burden that has often been associated with hand proofs, or proofs that make use of less automated proof assistance. We present proofs for two simple Java programs as a showcase.
Using Program Checking to Ensure the Correctness of Compiler Implementations
 Journal of Universal Computer Science (J.UCS
, 2003
"... Abstract: We evaluate the use of program checking to ensure the correctness of compiler implementations. Our contributions in this paper are threefold: Firstly, we extend the classical notion of blackbox program checking to program checking with certificates. Our checking approach with certificates ..."
Abstract

Cited by 12 (3 self)
 Add to MetaCart
Abstract: We evaluate the use of program checking to ensure the correctness of compiler implementations. Our contributions in this paper are threefold: Firstly, we extend the classical notion of blackbox program checking to program checking with certificates. Our checking approach with certificates relies on the observation that the correctness of solutions of NPcomplete problems can be checked in polynomial time whereas their computation itself is believed to be much harder. Our second contribution is the application of program checking with certificates to optimizing compiler backends, in particular code generators, thus answering the open question of how program checking for such compiler backends can be achieved. In particular, we state a checking algorithm for code generation based on bottomup rewrite systems from static single assignment representations. We have implemented this algorithm in a checker for a code generator used in an industrial project. Our last contribution in this paper is an integrated view on all compiler passes, in particular a comparison between frontend and backend phases, with respect to the applicable methods of program checking.
Abstract State Machines: A unifying view of models of computation and of system design frameworks
 Annals of Pure and Applied Logic
, 2005
"... We capture the principal models of computation and specification in the literature by a uniform set of transparent mathematical descriptions which—starting from scratch—provide the conceptual basis for a comparative study 1. 1 ..."
Abstract

Cited by 12 (5 self)
 Add to MetaCart
(Show Context)
We capture the principal models of computation and specification in the literature by a uniform set of transparent mathematical descriptions which—starting from scratch—provide the conceptual basis for a comparative study 1. 1
Translating java code to graph transformation systems
 IN PROC. OF ICGT ’04, LNCS 3256
, 2004
"... We propose a faithful encoding of Java programs (written in a suitable fragment of the language) to Graph Transformation Systems. Every program is translated to a set of rules including some basic rules, common to all programs and providing the operational semantics of Java (data and control) operat ..."
Abstract

Cited by 10 (0 self)
 Add to MetaCart
(Show Context)
We propose a faithful encoding of Java programs (written in a suitable fragment of the language) to Graph Transformation Systems. Every program is translated to a set of rules including some basic rules, common to all programs and providing the operational semantics of Java (data and control) operators, and the program specific rules, namely one rule for each method or constructor declared in the program. Besides sketching some potential applications of the proposed translation, we discuss some desing choices that ensure its correctness, and we report on how do we intend to extend it in order to handle several other features of the Java language.
A provably correct stackless intermediate representation for Java bytecode
, 2009
"... Abstract. The Java virtual machine executes stackbased bytecode. The intensive use of an operand stack has been identified as a major obstacle for static analysis and it is now common for static analysis tools to manipulate a stackless intermediate representation (IR) of bytecode programs. This pap ..."
Abstract

Cited by 7 (4 self)
 Add to MetaCart
(Show Context)
Abstract. The Java virtual machine executes stackbased bytecode. The intensive use of an operand stack has been identified as a major obstacle for static analysis and it is now common for static analysis tools to manipulate a stackless intermediate representation (IR) of bytecode programs. This paper provides such a bytecode transformation, describes its semantic correctness and evaluates its performance. We provide the semantic foundations for proving that an initial program and its IR behave similarly, in particular with respect to object creation and throwing of exceptions. The correctness of this transformation is proved with respect to a relation on execution traces taking into account that the object allocation order is not preserved by the transformation. 1