Results 1 
6 of
6
Mechanizing Programming Logics in Higher Order Logic
 in Current Trends in Hardware Verification and Automated Theorem Proving, ed. P.A. Subrahmanyam and Graham Birtwistle
, 1989
"... Formal reasoning about computer programs can be based directly on the semantics of the programming language, or done in a special purpose logic like Hoare logic. The advantage of the first approach is that it guarantees that the formal reasoning applies to the language being used (it is well known, ..."
Abstract

Cited by 59 (3 self)
 Add to MetaCart
Formal reasoning about computer programs can be based directly on the semantics of the programming language, or done in a special purpose logic like Hoare logic. The advantage of the first approach is that it guarantees that the formal reasoning applies to the language being used (it is well known, for example, that Hoare’s assignment axiom fails to hold for most programming languages). The advantage of the second approach is that the proofs can be more direct and natural. In this paper, an attempt to get the advantages of both approaches is described. The rules of Hoare logic are mechanically derived from the semantics of a simple imperative programming language (using the HOL system). These rules form the basis for a simple program verifier in which verification conditions are generated by LCFstyle tactics whose validations use the derived Hoare rules. Because Hoare logic is derived, rather than postulated, it is straightforward to mix semantic and axiomatic reasoning. It is also straightforward to combine the constructs of Hoare logic with other applicationspecific notations. This is briefly illustrated for various logical constructs, including termination statements, VDMstyle ‘relational’ correctness specifications, weakest precondition statements and dynamic logic formulae. The theory underlying the work presented here is well known. Our contribution is to propose a way of mechanizing this theory in a way that makes certain practical details work out smoothly.
Reasoning about procedure calls with repeated arguments and the referencevalue distinction
, 2003
"... A fundamental complexity in human understanding and reasoning about imperative, objectbased software systems has to do with the need to distinguish references and values of objects. It is possible to eliminate this complexity by (deep) copying values of all mutable objects, but this is too inefficie ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
A fundamental complexity in human understanding and reasoning about imperative, objectbased software systems has to do with the need to distinguish references and values of objects. It is possible to eliminate this complexity by (deep) copying values of all mutable objects, but this is too inefficient for typical, nontrivial objects. The problem of minimizing the impact of the referencevalue distinction without resorting to value copying manifests itself when objects are repeated as parameters to procedures. From a software engineering perspective, we consider alternative strategies to address the repeated argument problem ranging from ones that disallow repeated arguments to more permissive ones; from ones that do not require any new programming language mechanisms to ones that need new features. We introduce a parameter passing approach that neither requires the referencevalue distinction nor value copying to handle repeated arguments. We present a specificationaware, unrestricted, proof rule schema for procedure calls that is suitable for verification using alternative parameter passing techniques, separately or in combination.
Duration: Twelve lecturesSpecification and Verification I
"... These lecture notes are for the course entitled Specification and Verification I. Some of the material is derived from previously published sources. 1 Chapters 1–4 introduces the classical ideas of specification and proof of program properties due to Floyd and Hoare. Chapter 5 is an introduction to ..."
Abstract
 Add to MetaCart
These lecture notes are for the course entitled Specification and Verification I. Some of the material is derived from previously published sources. 1 Chapters 1–4 introduces the classical ideas of specification and proof of program properties due to Floyd and Hoare. Chapter 5 is an introduction to program refinement using an approach due to Paul Curzon. Chapter 6 presents higher order logic and Chapter 7 explains how FloydHoare logic can be defined within higher order logic. The topic of this course is the specification and verification of software. It is a prerequisite for the Part II course on the specification and verification of hardware entitled Specification and Verification II. Learning Guide These notes contain all the material that will be covered in the course. It should thus not be necessary to consult any textbooks etc. The copies of transparencies give the contents of the lectures. However note that I sometimes end up going faster or slower than expected so, for example, material shown in Lecture n might actually get covered in Lecture n+1 or Lecture n−1. The examination questions will be based on material in the lectures. Thus if I end up not covering some topic in the lectures, then I would not expect to set an examination question on it. This course has been fairly stable for several years, so past exam questions are a reasonable guide to the sort of thing I will set this year (and so are worth doing for practice).
Background reading on Hoare Logic
, 2012
"... Learning Guide for the CST Part II course. The examinable material in the course Hoare Logic consists of what is actually presented in the lectures. This document aims to provide background reading to support the lectures – think of it as a free downloadable textbook. Chapters 1–5 introduce classica ..."
Abstract
 Add to MetaCart
Learning Guide for the CST Part II course. The examinable material in the course Hoare Logic consists of what is actually presented in the lectures. This document aims to provide background reading to support the lectures – think of it as a free downloadable textbook. Chapters 1–5 introduce classical ideas of specification and proof of programs due to Floyd and Hoare. 1 Although much of the material is old – see the dates on some of the cited references – it is still a foundation for current research. Chapter 6 is a very brief introduction for the method of program refinement, which provides rules to ‘calculate ’ an implementation from a Hoarestyle specification. Chapter 7 is an introduction to the ideas of separation logic, a recent extension of Hoare logic, due to O’Hearn and Reynolds, for specifying and verifying programs that manipulate pointers. Note that there may be topics presented in the lectures that are not covered in this document and there may be material in this document that is not related to the topics covered in the lectures. The examination questions
and
"... This paper presents a semiformal denotational definition of the semantics of a version of domain relational calculus called DRC. A single basic design principle governs the semantic definition: each predicate (or formula) of DRC denotes a relation. The definition obtained is precise, short, and sys ..."
Abstract
 Add to MetaCart
This paper presents a semiformal denotational definition of the semantics of a version of domain relational calculus called DRC. A single basic design principle governs the semantic definition: each predicate (or formula) of DRC denotes a relation. The definition obtained is precise, short, and systematic. the relational Generalizations algebra are of operations of suggested, which correspond very directly with the semantics of DRC formulas. This work also suggests a more active role of semantic considerations in the design process of a query language, in order to simplify the specification of the language and, eventually, the language itself. 1.