• Corpus ID: 6461933

Edit and verify

  title={Edit and verify},
  author={Radu Grigore and Michal Moskal},
Automated theorem provers are used in extended static checking, where they are the performance bottleneck. Extended static checkers are run typically after incremental changes to the code. We propose to exploit this usage pattern to improve performance. We present two approaches of how to do so and a full solution. 

Figures and Tables from this paper

Strongest postcondition of unstructured programs

The passivation phase is defined precisely enough to allow a study of its algorithmic properties and the weakest precondition and strongest postcondition methods are presented in a unified way and then compared empirically.

The Dafny Integrated Development Environment

This paper presents an integrated development environment for Dafny-a programming language, verifier, and proof assistant-that addresses issues present in most state-of-the-art verifiers: low responsiveness and lack of support for understanding non-obvious verification failures.

Faster and More Complete Extended Static Checking for the Java Modeling Language

The multi-threaded version of ESC4 and its distributed prover back-end is presented, able to verify many more kinds of methods in part because of its use of novel techniques which apply multiple theorem provers.

The Design and Algorithms of a Verification Condition Generator

This dissertation discusses several problems loosely related, because they all involve a verification condition generator. The Boogie language is introduced; the architecture of a

Efficiency of Extended Static Checkers

It is quite unlikely that one idea or technique that decisively impacts the number of bugs released to users will be found, but the constant stream of research output, together with advocacy and teaching, will steadily raise the bar.

Fine-Grained Caching of Verification Results

A system for fine-grained caching of verification results that uses the program’s call graph and control-flow graph to focus the verification effort on just the parts of the program that were affected by the user's most recent modifications.



Simplify: a theorem prover for program checking

The article describes two techniques, error context reporting and error localization, for helping the user to determine the reason that a false conjecture is false, and includes detailed performance figures on conjectures derived from realistic program-checking problems.

Extreme Model Checking

It is shown that the lazy-abstraction algorithm, and its implementation in Blast, can be extended to support the fully automatic and incremental checking of temporal safety properties during software development.

Combinations of Model Checking and Theorem Proving

This paper surveys a number of methods for formal verification of reactive systems based on model checking and theorem proving, and describes the combinations of these methods.

Generating error traces from verification-condition counterexamples

The Spec# Programming System: An Overview

The goals and architecture of thespec# programming system, consisting of the object-oriented Spec# programming language, the Spec# compiler, and the Boogie static program verifier, are described.

Formal Verification of Ada Programs

The Penelope verification editor and its formal basis are described, a prototype system for the interactive development and verification of programs that are written in a rich subset of sequential Ada that belongs to the family of Larch interface languages.

Weakest-precondition of unstructured programs

This paper presents a novel approach for computing the weakest precondition of an unstructured program that is sound even in the presence of loops and the resulting logical expression provides more leeway for the theorem prover efficiently to attack the proof.

Formal Techniques for Java-Like Programs

This workshop aims to bring together people working in both formal techniques and interface specification languages, specification of software components and library packages, automated checking and verification of program pro perties, verification logics, language semantics, program analysis, type systems, security.

JML: A Notation for Detailed Design

JML is a behavioral interface specification language tailored to Java that uses Eiffel-style syntax combined with model-based semantics, as in VDM and Larch, and supports quantifiers, specification-only variables, and other enhancements that make it more expressive for specification and easier to use.

Incremental compilation in Magpie

Magpie is an interactive, integrate programming environment that supports the development of Pascal programs a powerful, single-user workstation that uses incremental compilation techniques to achieve performance levels that allow Pascal to be used interactively and as its own debugging language.