Markus Aderhold

Improvements in Formula Generalization

For proofs by induction it is often necessary to generalize statements to strengthen the induction hypotheses. This paper presents improved heuristics to generalize away subterms, unnecessary conditions and function symbols in a formula. This resolves shortcomings that we encountered within an experimental evaluation of generalization heuristics from the literature. Our generalization method has been implemented in the verification tool

Context Dependent Procedures and Computed Types in √eriFun

\checkmark

Automated synthesis of induction axioms for programs with second-order recursion

eriFun . An evaluation with examples from the literature as well as several case studies of our own demonstrates the success of our development.

Automated termination analysis for programs with second-order recursion

We present two enhancements of the functional language L which is used in the @?eriFun system to write programs and formulate statements about them. Context dependent procedures allow to stipulate the context under which procedures are sensibly executed, thus avoiding runtime tests in program code as well as verification of absence of exceptions by proving stuck-freeness of procedure calls. Computed types lead to more compact code, increase the readability of programs, and make the well-known benefits of type systems available to non-freely generated data types as well. Since satisfaction of context requirements as well as type checking becomes undecidable, proof obligations are synthesized to be proved by the verifier at hand, thus supporting static code analysis. Information about the type hierarchy is utilized for increasing the performance and efficiency of the verifier.

Second-order programs with preconditions

In order to support the verification of programs, verification tools such as ACL2 or Isabelle try to extract suitable induction axioms from the definitions of terminating, recursively defined procedures. However, these extraction techniques have difficulties with procedures that are defined by second-order recursion: There a first-order procedure f passes itself as an argument to a second-order procedure like

The L 1.0 Primer

\mathit{map}

Verification of Second-Order Functional Programs

,

Exemplary Formalization of Secure Coding Guidelines

\mathit{every}

A Fast Disprover for VeriFun

,

Choosing a Formalism for Secure Coding: FSM vs. LTL

\mathit{foldl}