Results 1 
4 of
4
Modular verification of software components in C
 IEEE TRANSACTIONS ON SOFTWARE ENGINEERING
, 2003
"... We present a new methodology for automatic verification of C programs against finite state machine specifications. Our approach is compositional, naturally enabling us to decompose the verification of large software systems into subproblems of manageable complexity. The decomposition reflects the mo ..."
Abstract

Cited by 233 (23 self)
 Add to MetaCart
(Show Context)
We present a new methodology for automatic verification of C programs against finite state machine specifications. Our approach is compositional, naturally enabling us to decompose the verification of large software systems into subproblems of manageable complexity. The decomposition reflects the modularity in the software design. We use weak simulation as the notion of conformance between the program and its specification. Following the abstractverifyrefine paradigm, our tool MAGIC first extracts a finite model from C source code using predicate abstraction and theorem proving. Subsequently, simulation is checked via a reduction to Boolean satisfiability. MAGIC is able to interface with several publicly available theorem provers and SAT solvers. We report experimental results with procedures from the Linux kernel and the OpenSSL toolkit.
Software model checking without source code
 In Proc. of the First NASA Formal Methods Symposium
, 2009
"... We present a framework, called AIR, for verifying safety properties of assembly language programs via software model checking. AIR extends the applicability of predicate abstraction and counterexample guided abstraction refinement to the automated verification of lowlevel software. By working at th ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
(Show Context)
We present a framework, called AIR, for verifying safety properties of assembly language programs via software model checking. AIR extends the applicability of predicate abstraction and counterexample guided abstraction refinement to the automated verification of lowlevel software. By working at the assembly level, AIR allows verification of programs for which source code is unavailable–such as legacy and COTS software–and programs that use features–such as pointers, structures, and objectorientation–that are problematic for sourcelevel software verification tools. In addition, AIR makes no assumptions about the underlying compiler technology. We have implemented a prototype of AIR and present encouraging results on several nontrivial examples. 1
This page is intentionally left blank. Automated Theorem Proving: Underlying Theory, Overarching Concepts, and Human Factor Issues
"... Abstract. In this memo, we discuss the topic of automated theorem proving. This note is intended to serve as an introduction for someone interested in the topic but who doesn’t have extensive background in formal proof systems. The topics covered in this memo are kept at a somewhat conceptual level ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. In this memo, we discuss the topic of automated theorem proving. This note is intended to serve as an introduction for someone interested in the topic but who doesn’t have extensive background in formal proof systems. The topics covered in this memo are kept at a somewhat conceptual level and pointers are provided to appropriate references for more indepth treatment of specific topics. In the first section, we present an overview of the theory involved in automated theorem proving, including core definitions, theoretical limitations, and practical implications. In the second section, we present the general concepts that are present in all theorem provers and list a few popular theorem proving systems as surveyed through the literature. Finally, in the third section, we give a list of the human factor issues that are inherent in the use of automated theorem provers and how those issues affect the practicality of using automated proof systems. 1
This page is intentionally left blank. Formal Software Verification: Model Checking and Theorem Proving
"... Formal verification of hardware and software systems has gained popularity in industry since the advent of the famous “Pentium bug ” in 1994, which caused Intel to recall faulty chips and take a loss of $475 million [1]. Since this event, formal verification of hardware systems has been commonplace ..."
Abstract
 Add to MetaCart
(Show Context)
Formal verification of hardware and software systems has gained popularity in industry since the advent of the famous “Pentium bug ” in 1994, which caused Intel to recall faulty chips and take a loss of $475 million [1]. Since this event, formal verification of hardware systems has been commonplace using mostly model checkers but also using theorem provers [2], [3]. The benefits reaped in the hardware sector has led the software sector to consider whether similar benefits could be achieved in the context of program correctness. Proofs of correctness about computer programs have been around since the early days of computer science, but academic developments were routinely ignored by industry citing advances in research as “impractical ” [4]. While there are drastic differences between the properties of software and the properties of hardware, namely the strict structure of hardware, the inherently finite state of hardware, and the restricted size of hardware [5]. While there are doubts about whether the anecdotal success of formal verification of industrial hardware can be replicated in the software sector, some progress has been made though numerous challenges still remain [2]. Before embarking on the description of theorem proving and model checking approaches