Automated tactics for separation logic VeriML Reconstruct Z3 Proof Safe incremental type checker Certifying code transformation Proof carrying hardware IP

Automated tactics for separation logic Version 1 Certified verifier for a fragment of separation logic in Coq Without predicates ( list, tree … ) Prover written in SML handle these predicates and output proof trace Tactic to reconstruct proof from these proof trace in Coq Version 2 Hard coded list and tree into the certified verifier Use a forked version Coq which supports native arrays to speed up the verifier Version 3 ( Ongoing ) More generic way to support user defined predicates

Reconstruct Z3 Proof Reconstruct proof in VeriML using output from Z3

Start from SAT Solvers

Example

SAT Modulo Theories(SMT solver)

Example

Interaction between SAT and SMT ABCDE

Reconstruct proof If sat: apply the assignment and check the result is true If unsat: check the resolution tree Checking resolution step (SAT solver) Checking theory lemmas (SMT solver) Combination of theories

What we need resolution checker checker for each theory checker for the resolution tree which calls these two kinds of checkers at each step

Example

Encoding in VeriML

Interpretation

Start from SAT solver Resolution Chain: List Nat Resolve : Clause->Clause->Clause resolution between clause C1 and C2. Resolution checker: Resolution Chain-> Clause for resolution chain [n1,n2,…n] and state S, R(..(R( S[n1], S[n2]),…),S[n]) Proof trace: List (clauseID*Resolution Chain) Reconstruct the proof: List.fold (fun (id,rc) => set s (resolution_checker rc) id) trace After this, we have the empty clause in state which indicates the state is not valid

Example Initial State: [ [2,4], [2,5,6], [3,6], [7] ] Resolutions: [ (5,[1,3,0]), (6,[2,3] ), (7,[5,6]) ] Resolve two clause: [2,4] [2,5,6]  [2,6] ( a modified merge sort )

Naïve framework for SMT solver Certificate from different theories Inductive cert: | sat_solver sat_cert | euf_solver euf_cert | lia_solver lia_cert …. Trace might be like: List (clauseID*cert) Checkers for each theory And finally the checker for SMT solver checker s trace = List.fold (fun (id,cert) => set s (cert_checker cert) id

ProblemWitness SMT Resolution CNF EUF LIA VeriML Checker

Z3 Proof Example 34 Axiom 19 core rules : mostly are propositional reasoning 5 equality rules : refl, symm, trans, … 7 quantifier rules : quant-inst, quant-intro, … 3 theory rules : rewrite, inconsistent, …

Reconstruction Overall approach: one proof method for every Z3 inference rule depth-first traversal of Z3 proof

Conclusion A prototype to reconstruct zChaff(SAT solver) proof Very slow in performance Ongoing with Z3 reconstruction

Safe Incremental Type Checker Type checking is more and more an interaction between the programmer and the type-checker The richer the type system is, the more expensive type checking gets Example Type inference ( unification) Dependent types Very large term ( proof term ) Complex language ( C++ )

Goal Reuse already-computed results Recheck only the modified part and where it affects Example let f x = x + 1 in (f 2) let f x = 2 * (x + 1) in (f 2) let f x = (let y = true in x + 1) in (f 2) let f x = x > 1 in (f 2)

Benefit fast type checking modified code this could also be used to tactic language, and refinement? typed version control as we always have well-typed program and its type derivations “undo” for free

Difficulties

A language to store typing derivations VeriML support contextual terms in computation language, thus possible to present typing derivations How to make it generic? A language to describe delta between different versions Got stuck here

Scratch

Certifying Code Transformation How to certify code transformation? Verified Compiler Translation Validation VeriML approach

Verified Compiler

Translation Validation

Approach with VeriML

Naïve Example

Scratch ImplementationLogical language Heap implementation Language definition and semantics Computation language Symbolic execution(VCGen) Tacitc to proof Hoare Triple Practical Code transformation examples

Conclusion The thing we need to proof isn't less than translation validation we can do it in a single lanuguage which easier to write proof with and we get more proof The whole picture is still vague

Proof Carrying Hardware Current work A formalization of Intel 8051 microcontroller in Coq RC5 hash algorithm Proof certain ports won’t “leak” secret