Combining and Strengthening Program Analysis and Verification

This thesis is about methods for establishing semantic properties of programs and how those methods can be strengthened. Finding (semi-)algorithms for deciding semantic properties is a non-trivial task and such algorithms will, by necessity, give approximate answers. This means that for any property of interest, there is a spectrum of algorithms computing answers to various degrees of precision, ranging from computationally cheap, low-precision algorithms to expensive, potentially non-terminating algorithms with very high precision. Finding approximations precise enough to be useful, and that at the same time make the algorithms cheap enough, is a real challenge. In this thesis we consider program analysis and program verification, which are two approaches for establishing program properties with contrasting requirements regarding precision and cost. Common to these two approaches is the desire to move closer to the middle of the spectrum of algorithms. For algorithms formulated as program analyses, this means increasing their precision, and for algorithms formulated as program verifiers, it means making them terminate without user interaction for a larger set of programs. The work presented in this thesis can be divided into three parts. The first part investigates the impact a number of features have on the precision of a type-based program analysis for Haskell. The results presented, make it easier for a designer of a type-based program analysis to choose what features to add to the analysis in order to get sufficiently high precision. The second part concerns how program verification can be integrated with program analysis in order to make the verification cheaper and more automatic. We show how a program analysis can be embedded in the tactic language of a theorem prover to allow for a close integration of program analysis and verifi- cation. We also show, in particular, how a dependence analysis can be used in a theorem prover for Java to make the handling of loops more automatic. The third part concerns how type-based program analysis can be strengthened by plugging in additional, externally computed information. We do this by presenting a modular method for parameterizing type-based program analyses over information about the analyzed program’s execution. The parameterization is done in such a way that a modular proof of correctness is obtained, removing the need to prove correctness of each instantiation separately. We also show how our method of parameterization can be used to allow for flow-sensitive heap types by plugging in alias information