Self compilation and self verification
This dissertation presents two pieces of work, one building on the other, that advance the state of the art of formal verification. The focus, in both cases, is on proving end to end correctness for realistic implementations of computer software. The first piece is a verified compiler for a stateful higher order functional programming language, CakeML, which is packaged into a verified read eval print loop (REPL) The second piece is a verified theorem prover kernel for higher order logic (HOL) designed to run in the verified REPL. Self compilation is the key idea behind the verification of the CakeML REPL, in particular, the new technique of proof grounded bootstrapping of a verified compiler. The verified compiler is bootstrapped within the theorem prover used for its verification, and then packaged into a REPL. The result is an implementation of the REPL in machine code, verified against machine code semantics. All the end to end correctness theorems linking this low level implementation to its desired semantics are proved within the logic of the theorem prover. Therefore the trusted computing base (TCB) of the final implementation is smaller than for any previously verified compiler. Just as self compilation is a benchmark by which to judge a compiler, I propose self verification as a benchmark for theorem provers, and present a method by which a theorem prover could verify its own implementation. By applying proofgrounded compilation (i.e. proof grounded bootstrapping applied to something other than a compiler) to an implementation of a theorem prover, we obtain a theorem prover whose machine code implementation is verified. To connect this result back to the semantics of the logic of the theorem prover, we need to formalise that semantics and prove a refinement theorem. I present some advances in the techniques that can be used to formalise HOL within itself, as well as demonstrating that the theorem prover, and its correctness proof, can be pushed through the verified compiler. My thesis is that verification of a realistic implementation can be produced mostly automatically from a verified high level implementation, via the use of verified compilation. I present a verified compiler and explain how it was bootstrapped to achieve a small TCB, and then explain how verified compilation can be used on a larger application, in particular, a theorem prover for higher order logic. The application has two parts, one domain specific and the other generic. For the domain specific part, I formalise the semantics of higher order logic and prove its inference system sound. For the generic part, I apply proof grounded compilation to produce the verified implementation.