4 research outputs found
An observationally complete program logic for imperative higher-order functions
We establish a strong completeness property called observational completeness of the program logic for imperative, higher-order functions introduced in [1]. Observational completeness states that valid assertions characterise program behaviour up to observational congruence, giving a precise correspondence between operational and axiomatic semantics. The proof layout for the observational completeness which uses a restricted syntactic structure called finite canonical forms originally introduced in game-based semantics, and characteristic formulae originally introduced in the process calculi, is generally applicable for a precise axiomatic characterisation of more complex program behaviour, such as aliasing and local state
Logical Reasoning for Higher-Order Functions with Local State
We introduce an extension of Hoare logic for call-by-value higher-order
functions with ML-like local reference generation. Local references may be
generated dynamically and exported outside their scope, may store higher-order
functions and may be used to construct complex mutable data structures. This
primitive is captured logically using a predicate asserting reachability of a
reference name from a possibly higher-order datum and quantifiers over hidden
references. We explore the logic's descriptive and reasoning power with
non-trivial programming examples combining higher-order procedures and
dynamically generated local state. Axioms for reachability and local invariant
play a central role for reasoning about the examples.Comment: 68 page
Towards feasible, machine-assisted verification of object-oriented programs
This thesis provides an account of a development of tools towards making verification of object-oriented programs more feasible. We note that proofs in program verification logics are typically long, yet, mathematically, not very deep; these observations suggest the thesis that computers can significantly ease the burden of program verification. We give evidence supporting this by applying computers to (1) automatically check and (2) automatically infer large parts of proofs. Taking the logic (AL) of Abadi and Leino as our starting point, we initially show how the logic can be embedded into a higher-order logic theorem prover, by way of introducing axioms, using a mix of both higher-order abstract syntax (HOAS) and a direct embedding of the assertion logic. The tenacity and exactness of the theorem prover ensures that no proof obligation is inadvertently lost during construction of a proof; we inherit any automatic facilities such as tactics which take us part way towards goal (2); and moreover, we achieve goal (1), since we inherit machine proofs which can be checked automatically. We present som