Type-based data structure verification

Abstract

We present a refinement type-based approach for the static verification of complex data structure invariants. Our approach is based on the observation that complex data structures are typically fashioned from two elements: recursion (e.g., lists and trees), and maps (e.g., arrays and hash tables). We introduce two novel type-based mechanisms targeted towards these elements: recursive refinements and polymorphic refinements. These mechanisms automate the challenging work of generalizing and instantiating rich universal invariants by piggybacking simple refinement predicates on top of types, and carefully dividing the labor of analysis between the type system and an SMT solver [6]. Further, the mechanisms permit the use of the abstract interpretation framework of liquid type inference [22] to automatically synthesize complex invariants from simple logical qualifiers, thereby almost completely automating the verification. We have implemented our approach in DSOLVE, which uses liquid types to verify OCAML programs. We present experiments that show that our type-based approach reduces the manual annotation required to verify complex properties like sortedness, balancedness, binary-search-ordering, and acyclicity by more than an order of magnitude.

Low-level liquid types

“…Liquid Type Inference Finally, we use liquid type inference to infer refinement types and thus automatically discover data structure invariants. This step is similar to previous work [29,20]; we give a brief outline here. As before, we observe that our type checking rules encode an algorithm for type inference and so we perform type inference by attempting to produce a type derivation.…”

“…ATS [35] combines linear types with stateful views and explicit programmer-provided proof terms to specify and verify safety properties of an imperative language. In contrast to the above, we have previously demonstrated [29,20] that for high-level languages the abstract interpretation enabled by Liquid Types can drastically reduce the annotations and automate verification. Our work brings those benefits to the low-level, imperative setting.…”

“…Type inference occurs in three phases: the first infers Basic types for the program; the second inserts location fold and unfold operations where necessary; and the third infers refinement types using liquid type inference. Basic Type Inference In previous work [29,20], we based our type inference techniques on the rich type information provided by ML's type system. Because C programs are essentially untyped, We first use the declared C types of all functions in the program to generate corresponding Basic type schemas.…”

“…We demonstrated that this symbiotic combination enables the highly automated verification of complex data-sensitive properties of highlevel, functional programs [20]. Unfortunately, the very nature of low-level, imperative code, typically written in C, makes the translation of type-based mechanisms to the setting of systems software verification extremely challenging.…”

Towards a scalable software model checker for higher-order programs

“…There are several studies [5,10,11,21,[24][25][26][27][28] that aim to infer dependent types for higher-order programs with recursive data structures. Rondon et al's liquid type inference [11,21] is a semi-automated verification method that requires users to provide templates of predicates, called logical qualifiers.…”