Results 1  10
of
23
Ten Years of Hoare's Logic: A Survey  Part l
, 1981
"... A survey of various results concerning Hoare's approach to proving partial and total correctness of programs is presented. Emphasis is placed on the soundness and completeness issues. Various proof systems for while programs, recursive procedures, local variable declarations, and procedures with par ..."
Abstract

Cited by 66 (2 self)
 Add to MetaCart
A survey of various results concerning Hoare's approach to proving partial and total correctness of programs is presented. Emphasis is placed on the soundness and completeness issues. Various proof systems for while programs, recursive procedures, local variable declarations, and procedures with parameters, together with the corresponding soundness, completeness, and incompleteness results, are discussed.
Java Program Verification via a Hoare Logic with Abrupt Termination
 Fundamental Approaches to Software Engineering (FASE 2000), number 1783 in LNCS
, 2000
"... This paper formalises a semantics for statements and expressions (in sequential imperative languages) which includes nontermination, normal termination and abrupt termination (e.g. because of an exception, break, return or continue). This extends the traditional semantics underlying e.g. Hoare logi ..."
Abstract

Cited by 63 (6 self)
 Add to MetaCart
This paper formalises a semantics for statements and expressions (in sequential imperative languages) which includes nontermination, normal termination and abrupt termination (e.g. because of an exception, break, return or continue). This extends the traditional semantics underlying e.g. Hoare logic, which only distinguishes termination and nontermination. An extension of Hoare logic is elaborated that includes means for reasoning about abrupt termination (and sideeffects). It prominently involves rules for reasoning about while loops, which may contain exceptions, breaks, continues and returns. This extension applies in particular to Java. As an example, a standard pattern search algorithm in Java (involving a while loop with returns) is proven correct using the prooftool PVS.
Structured programming with go to statements
 Computing Surveys
, 1974
"... A consideration of several different examples sheds new light on the problem of ereating reliable, wellstructured programs that behave efficiently. This study focuses largely on two issues: (a) improved syntax for iterations and error exits, making it possible to write a larger class of programs c ..."
Abstract

Cited by 55 (3 self)
 Add to MetaCart
A consideration of several different examples sheds new light on the problem of ereating reliable, wellstructured programs that behave efficiently. This study focuses largely on two issues: (a) improved syntax for iterations and error exits, making it possible to write a larger class of programs clearly and efficiently without go to state
A compositional logic for control flow
 In 7th International Conference on Verification, Model Checking and Abstract Interpretation (VMCAI’06
, 2006
"... Abstract. We present a program logic, Lc, which modularly reasons about unstructured control flow in machinelanguage programs. Unlike previous program logics, the basic reasoning units in Lc are multipleentry and multipleexit program fragments. Lc provides finegrained composition rules to compose ..."
Abstract

Cited by 35 (1 self)
 Add to MetaCart
Abstract. We present a program logic, Lc, which modularly reasons about unstructured control flow in machinelanguage programs. Unlike previous program logics, the basic reasoning units in Lc are multipleentry and multipleexit program fragments. Lc provides finegrained composition rules to compose program fragments. It is not only useful for reasoning about unstructured control flow in machine languages, but also useful for deriving rules for common controlflow structures such as whileloops, repeatuntilloops, and many others. We also present a semantics for Lc and prove that the logic is both sound and complete with respect to the semantics. As an application, Lc and its semantics have been implemented on top of the SPARC machine language, and are embedded in the Foundational ProofCarrying Code project to produce memorysafety proofs for machinelanguage programs. 1
Typed lambdacalculus in classical ZermeloFraenkel set theory
 ARCHIVE OF MATHEMATICAL LOGIC
, 2001
"... In this paper, we develop a system of typed lambdacalculus for the ZermeloFraenkel set theory, in the framework of classical logic. The first, and the simplest system of typed lambdacalculus is the system of simple types, which uses the intuitionistic propositional calculus, with the only connect ..."
Abstract

Cited by 34 (9 self)
 Add to MetaCart
In this paper, we develop a system of typed lambdacalculus for the ZermeloFraenkel set theory, in the framework of classical logic. The first, and the simplest system of typed lambdacalculus is the system of simple types, which uses the intuitionistic propositional calculus, with the only connective #. It is very important, because the well known CurryHoward correspondence between proofs and programs was originally discovered with it, and because it enjoys the normalization property : every typed term is strongly normalizable. It was extended to second order intuitionistic logic, in 1970, by J.Y. Girard[4], under the name of system F, still with the normalization property. More recently, in 1990, the CurryHoward correspondence was extended to classical logic, following Felleisen and Griffin [6] who discovered that the law of Peirce corresponds to control instructions in functional programming
A compositional natural semantics and Hoare logic for lowlevel languages
 In: Proceedings of the Second Workshop on Structured Operational Semantics
, 2005
"... The advent of proofcarrying code has generated significant interest in reasoning about lowlevel languages. It is widely believed that lowlevel languages with jumps must be difficult to reason about by being inherently nonmodular. We argue that this is untrue. We take it seriously that, different ..."
Abstract

Cited by 15 (4 self)
 Add to MetaCart
The advent of proofcarrying code has generated significant interest in reasoning about lowlevel languages. It is widely believed that lowlevel languages with jumps must be difficult to reason about by being inherently nonmodular. We argue that this is untrue. We take it seriously that, differently from statements of a highlevel language, pieces of lowlevel code are multipleentry and multipleexit. And we define a piece of code to consist of either a single labelled instruction or a finite union of pieces of code. Thus we obtain a compositional natural semantics and a matching Hoare logic for a basic lowlevel language with jumps. By their simplicity and intuitiveness, these are comparable to the standard natural semantics and Hoare logic of While. The Hoare logic is sound and complete wrt. the semantics and allows for compilation of proofs of the Hoare logic of While.
The Early Search for Tractable Ways of Reasoning About Programs
 IEEE Annals of the History of Computing
, 2003
"... This paper traces the important steps in the history up to around 1990 of research on reasoning about programs. The main focus is on sequential imperative programs but some comments are made on concurrency. Initially, researchers focussed on ways of verifying that a program satisfies its specifi ..."
Abstract

Cited by 15 (2 self)
 Add to MetaCart
This paper traces the important steps in the history up to around 1990 of research on reasoning about programs. The main focus is on sequential imperative programs but some comments are made on concurrency. Initially, researchers focussed on ways of verifying that a program satisfies its specification (or that two programs were equivalent). Over time it became clear that post facto verification is only practical for small programs and attention turned to verification methods which support the development of programs; for larger programs it is necessary to exploit a notation of compositionality. Coping with concurrent algorithms is much more challenging  this and other extensions are considered briefly. The main thesis of this paper is that the idea of reasoning about programs has been around since they were first written; the search has been to find tractable methods.
On the Search for Tractable Ways of Reasoning about Programs
, 2001
"... This paper traces the important steps in the history up to around 1990 of research on reasoning about programs. The main focus is on sequential imperative programs but some comments are made on concurrency. Initially, researchers focussed on ways of verifying that a program satifies its specific ..."
Abstract

Cited by 9 (1 self)
 Add to MetaCart
This paper traces the important steps in the history up to around 1990 of research on reasoning about programs. The main focus is on sequential imperative programs but some comments are made on concurrency. Initially, researchers focussed on ways of verifying that a program satifies its specification (or that two programs were equivalent). Over time it has become clear that post facto verification is only practical for small programs and attention turned to verification methods which support the development of programs; for larger programs it is necesary to exploit a notion of composability.
Semantic foundations for typed assembly languages
 Prog. Languages and Systems (TOPLAS
, 2008
"... Typed Assembly Languages (TALs) are used to validate the safety of machinelanguage programs. The Foundational ProofCarrying Code project seeks to verify the soundness of TALs using the smallest possible set of axioms—the axioms of a suitably expressive logic plus a specification of machine semanti ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
Typed Assembly Languages (TALs) are used to validate the safety of machinelanguage programs. The Foundational ProofCarrying Code project seeks to verify the soundness of TALs using the smallest possible set of axioms—the axioms of a suitably expressive logic plus a specification of machine semantics. This paper proposes general semantic foundations that permit modular proofs of the soundness of TALs. These semantic foundations include Typed Machine Language (TML), a type theory for specifying properties of lowlevel data with powerful and orthogonal type constructors, and Lc, a compositional logic for specifying properties of machine instructions with simplified reasoning about unstructured control flow. Both of these components, whose semantics we specify using higherorder logic, are useful for proving the soundness of TALs. We demonstrate this by using TML and Lc to verify the soundness of a lowlevel, typed assembly language, LTAL, which is the target of our coreMLtosparc compiler. To prove the soundness of the TML type system we have successfully applied a new approach, that of stepindexed logical relations. This approach provides the first semantic model for a type system with updatable references to values of impredicative quantified types. Both impredicative polymorphism and mutable references are essential when representing function closures in compilers with typed closure conversion, or when compiling objects to simpler typed primitives.
Sequential Process Logics: Soundness Proofs
, 2003
"... We prove soundness results of the proof systems for basic speci cation logics for sequentially typed calculi, oering a basis for their applications. The proofs for dierent logics enjoy modularity in correspondence with that of their proof sustems. 1 ..."
Abstract

Cited by 6 (4 self)
 Add to MetaCart
We prove soundness results of the proof systems for basic speci cation logics for sequentially typed calculi, oering a basis for their applications. The proofs for dierent logics enjoy modularity in correspondence with that of their proof sustems. 1