Refinement reflection: complete verification with SMT

@article{Vazou2018RefinementRC,
  title={Refinement reflection: complete verification with SMT},
  author={Niki Vazou and Anish Tondwalkar and Vikraman Choudhury and Ryan Scott and R. Newton and P. Wadler and Ranjit Jhala},
  journal={Proceedings of the ACM on Programming Languages},
  year={2018},
  volume={2},
  pages={1 - 31}
}
We introduce Refinement Reflection, a new framework for building SMT-based deductive verifiers. The key idea is to reflect the code implementing a user-defined function into the function’s (output) refinement type. As a consequence, at uses of the function, the function definition is instantiated in the SMT logic in a precise fashion that permits decidable verification. Reflection allows the user to write equational proofs of programs just by writing other programs using pattern-matching and… Expand
ESVERIFY: Verifying Dynamically-Typed Higher-Order Functional Programs by SMT Solving
TLDR
ESVERIFY, a program verifier for JavaScript based on SMT solving, supporting functional correctness properties comparable to languages with refinement and dependent function types, and a bounded quantifier instantiation algorithm that prevents matching loops and avoids ad-hoc instantiation heuristics. Expand
System FR: formalized foundations for the stainless verifier
TLDR
The design, implementation, and foundation of a verifier for higher-order functional programs with generics and recursive data types are presented and the soundness of a type-checker with respect to call-by-value semantics is proved, ensuring type safety and normalization for typeable programs. Expand
System FR as Foundations for Stainless
TLDR
The design, implementation, and foundation of a verifier for higher-order functional programs with generics and recursive data types are presented and a reducibility argument is formalized using the Coq proof assistant and the soundness of a type-checker with respect to call-by-value semantics is proved, ensuring type safety and normalization for typeable programs. Expand
Functional Extensionality for Refinement Types
TLDR
A new approach to equality in Liquid Haskell is developed: a propositional equality in a library the authors call PEq, which avoids the unsoundness while still proving useful equalities at higher types; its use in several case studies is demonstrated. Expand
Statically verified refinements for multiparty protocols
With distributed computing becoming ubiquitous in the modern era, safe distributed programming is an open challenge. To address this, multiparty session types (MPST) provide a typing discipline forExpand
Refinements of Futures Past: Higher-Order Specification with Implicit Refinement Types (Extended Version)
TLDR
This work introduces Implicit Refinement Types which turn ghost variables into implicit pair and function types, in a way that lets the refinement typechecker automatically synthesize their values at compile time. Expand
Smtlink 2.0
TLDR
Smtlink 2.0 makes major improvements over the initial version with respect to soundness, extensibility, ease-of-use, and the range of types and associated theory-solvers supported. Expand
Generic and flexible defaults for verified, law-abiding type-class instances
TLDR
It is observed that any algebraic data type has an equivalent representation type that is composed of simpler, smaller types that are simpler to prove theorems over and derived proofs for the original datatype by reusing the corresponding proof over the representation type. Expand
Program synthesis with algebraic library specifications
TLDR
JLibSketch is introduced, a Java program synthesis tool that allows library behavior to be described with algebraic specifications, which are rewrite rules for sequences of method calls, e.g., encryption followed by decryption (with the same key) is the identity. Expand
Verifying replicated data types with typeclass refinements in Liquid Haskell
TLDR
This paper presents an extension to Liquid Haskell that facilitates stating and semi-automatically proving properties of typeclasses, and implements a framework for programming distributed applications based on replicated data types (RDTs). Expand
...
1
2
3
4
...

References

SHOWING 1-10 OF 75 REFERENCES
Refinement types for Haskell
TLDR
A stratified type system that labels binders as potentially diverging or not, and that (circularly) uses refinement types to verify the labeling, that is able to prove 96% of all recursive functions terminating, while requiring a modest 1.7 lines of termination-annotations per 100 lines of code. Expand
Dafny: An Automatic Program Verifier for Functional Correctness
TLDR
A tour of the language and verifier Dafny, which has been used to verify the functional correctness of a number of challenging pointer-based programs, is given and the full functional specification of the Schorr-Waite algorithm is shown. Expand
Verifying Relational Properties of Functional Programs by First-Order Refinement
TLDR
A restricted form of higher-order refinement types where refinement predicates can refer to functions is introduced, and a systematic program transformation is formalized to reduce type checking/inference for higher-orders refinement types to that for first- order refinement types, so that the latter can be automatically solved by using an existing software model checker. Expand
Dependent types and multi-monadic effects in F*
TLDR
A new, completely redesigned, version of F*, a language that works both as a proof assistant as well as a general-purpose, verification-oriented, effectful programming language that confirms F*'s pay-as-you-go cost model. Expand
Satisfiability Modulo Recursive Programs
TLDR
The system, Leon, verified detailed correctness properties for functional data structure implementations, as well as syntax tree manipulations, and was found to be fast for both finding counterexamples and finding correctness proofs, and to scale to larger programs than alternative techniques. Expand
Type-preserving compilation of end-to-end verification of security enforcement
TLDR
A type-preserving compiler that translates programs written in FINE, a source-level functional language with dependent refinements and affine types, to DCIL, a new extension of the .NET Common Intermediate Language, to reduce the proof burden on source programmers. Expand
Zeno: An Automated Prover for Properties of Recursive Data Structures
Zeno is a new tool for the automatic generation of proofs of simple properties of functions over recursively defined data structures. It takes a Haskell program and an assertion as its goal and triesExpand
Abstract Refinement Types
We present abstract refinement types which enable quantification over the refinements of data- and function-types. Our key insight is that we can avail of quantification while preserving SMT-basedExpand
Programming up to Congruence
TLDR
The design of Zombie is presented, a dependently-typed programming language that uses an adaptation of a congruence closure algorithm for proof and type inference that allows the type checker to automatically use equality assumptions from the context when reasoning about equality. Expand
Refinement types for TypeScript
TLDR
This work develops a formal system for RSC that delineates the interaction between refinement types and mutability, and enables flow-sensitive reasoning by translating input programs to an equivalent intermediate SSA form, and proves safety for the input programs. Expand
...
1
2
3
4
5
...