Towards a scalable software model checker for higher-order programs

Abstract

In our recent paper, we have shown how to construct a fullyautomated program verification tool (so called a "software model checker") for a tiny subset of functional language ML, by combining higher-order model checking, predicate abstraction, and CE-GAR. This can be viewed as a higher-order counterpart of previous software model checkers for imperative languages like BLAST and SLAM. The naïve application of the proposed approach, however, suffered from scalability problems, both in terms of efficiency and supported language features. To obtain more scalable software model checkers for full-scale functional languages, we propose a series of optimizations and extensions of the previous approach. Among others, we introduce (i) selective CPS transformation, (ii) selective predicate abstraction, and (iii) refined predicate discovery as optimization techniques; and propose (iv) functional encoding of recursive data structures and control operations to support a larger subset of ML. We have implemented the proposed methods, and obtained promising results.

Verifying relational properties of functional programs by first-order refinement

“…Since the verification problem is undecidable, 5 we aim to develop a sound but incomplete method below. As explained in Section 1, our approach is to use program transformation to reduce the (semantic) type checking problem |= t : τ to the first-order refinement type checking problem |= t : τ where τ does not contain any function variables in refinement predicates, and to check |= t : τ using an automated verification tool such as MoCHi [9,13,18], which combines higher-order model checking [8] and predicate abstraction.…”

“…The transformation (−) in the previous section allowed us to reduce the refinement type checking |= t : τ to the firstorder refinement type checking |= (t) : (τ ) , but it does not necessarily enable us to prove the latter by using the existing automated verification tools [12,17,16,9,19,13]. This is due to the incompleteness of the tools for proving |= (t) : (τ ) .…”

“…We have implemented a prototype, automated verifier for higher-order functional programs as an extension to a software model checker MoCHi [9,13] for a subset of OCaml. Table 1 shows the results of the experiments.…”

“…We formalize the idea sketched above and prove the soundness of the transformation. We also report on a prototype implementation of the approach as an extension to the software model checker MoCHi [9,13] for a subset of OCaml. The implementation takes a program and its specification (in the form of refinement types) as input, and verifies them automatically (without invariant annotations for auxiliary functions) by applying the above transformations and calling MoCHi as a backend.…”

Complexity of Model-Checking Call-by-Value Programs

“…Sato et al [16] employed the selective CPS translation [14] to avoid unnecessary growth of the order, using a type and effect system to capture effect-free fragments and then added continuation parameters to only effectful parts.…”