Formal verification at Intel

  title={Formal verification at Intel},
  author={John Harrison},
  journal={18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings.},
  • J. Harrison
  • Published 22 June 2003
  • Computer Science
  • 18th Annual IEEE Symposium of Logic in Computer Science, 2003. Proceedings.
As designs become more complex, formal verification techniques are becoming increasingly important in the hardware industry. Many different methods are used, ranging from propositional tautology checking up to use of interactive higher-order theorem provers. Our own work is mainly concerned with the formal verification of floating-point mathematical functions. As this paper illustrates, such applications require a rather general mathematical framework and the ability to automate special-purpose… 

Formal Verification of n-bit ALU Using Theorem Proving

This project recently proposed a higher-order-logic formalization of all the commonly used combinational circuits, like basic gates, adders, multiplier, multiplexers, demultiplexer, decoders and encoders, using the HOL4 theorem prover, and describes this formally verified library.

Exploiting PSL standard assertions in a theorem-proving-based verification environment

This paper presents the work on development of the semi-automated theorem-proving based verification system ROVERIFIC that makes use of existing design assertions, and defines generic predicate templates that capture the semantics of PSL, and a subset of Verilog.

Towards Strong Higher-Order Automation for Fast Interactive Verification

The Matryoshka project aims to enrich superposition and SMT with higher-order reasoning in a careful manner, to preserve their good properties and bring a new level of automation to the users of proof assistants.

Combining model checking and theorem proving

A restricted form of a higher order logic representation calculus for binary decision diagrams to interface the model checker to a high-performance BDD engine and implements an executable theory for counterexample-guided abstraction refinement that also uses a SAT solver.

Solving Quantified First Order Formulas in Satisfiability Modulo Theories

Satisfiability Modulo Theories (SMT) solvers have been developed to handle formulas in a more expressive first order logic, and check satisfiability with regard to some background theories, such as theories of arithmetic, arrays and bit-vectors.

Trustworthy numerical computation in Scala

This work presents a library solution for rigorous arithmetic computation that tracks a (double) floating point value, but also a guaranteed upper bound on the error between this value and the ideal value that would be computed in the real-value semantics.

Formal modeling for consistency checking of signal transition graph

The formal modeling scheme of a signal transition graph is proposed along with the consistency property in term of the linear temporal formula and the result shows that the method can verify consistency property automatically.

History of Interactive Theorem Proving

The development of systems based on type theory, LCF, and set theory are presented, with focus on improvement throughout history, on the LCF prover Isabelle/HOL, the set theory prover Mizar and the general application of all these systems.

On Rigorous Numerical Computation as a Scala Library

This work presents a library solution for rigorous arithmetic computation that seamlessly integrates into the Scala programming language, thanks to its extensibility mechanisms such as implicit conversions and the treatment of arithmetic operations as method calls.

On the Design and Implementation of SmartFloat and AffineFloat

This work presents a library solution for rigorous arithmetic computation that tracks a (double) floating point value, but also a guaranteed upper bound on the error between this value and the ideal value that would be computed in the real-value semantics.



Divider Circuit Verification with Model Checking and Theorem Proving

This paper discusses a formal verification case study based on a combination of theorem-proving and model-checking techniques that addresses the correctness of a floating-point divider unit of an Intel IA-32 microprocessor.

Superscalar Processor Verification Using Efficient Reductions of the Logic of Equality with Uninterpreted Functions to Propositional Logic

This work achieves a significant speedup in the verification of dual-issue superscalar processors, compared to the result by Burch and Dill, while using an entirely automatic tool.

Symbolic Simulation for Correct Machine Design

Symbolic simulation is described, a method similar to symbolic execution of programs, and its use in proving the correctness of machine architectures implemented in microcode.

A Mizar Mode for HOL

The addition of another style of HOL proofs, inspired by Mizar, is described, which is believed to combine the secure extensibility and interactivity of HOL with Mizar’s readability and lack of logical prescriptiveness.

Proof Style

This talk discusses the strengths and weaknesses of declarative and procedural styles for proofs in pure mathematics and for veriication applications, and explores the bias towards a `procedural' or`declarative' proof style.

Automatic verification of Pipelined Microprocessor Control

The method handles more complicated designs, and requires less human intervention, than existing methods, and results from an efficient validity checker for a logic of uninterpreted functions with equality.

Processor verification using efficient reductions of the logic of uninterpreted functions to propositional logic

Positive equality allows us to overcome the experimental blow-up experienced previously when verifying microprocessors with load, store, and branch instructions and two methods to translate formulas in EUF into propositional logic are presented.

Efficiency in a fully-expansive theorem prover

This thesis seeks to identify sources of non-inherent ine ciency in the HOL system and proposes some general-purpose and some specialised techniques for eliminating it and a framework in which part of the computation involved in HOL proofs can be postponed to enable users to make better use of their time.

Lifted-FL: A Pragmatic Implementation of Combined Model Checking and Theorem Proving

This work has constructed a system that seamlessly integrates symbolic trajectory evaluation based model checking with theorem proving in a higher-order classical logic by using the same programming language as both the meta and object language of theorem proving.

Program verification: the very idea

The success of program verification as a generally applicable and completely reliable method for guaranteeing program performance is not even a theoretical possibility.