A framework for defining logics
Journal of the ACM (JACM)
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
From system F to typed assembly language
ACM Transactions on Programming Languages and Systems (TOPLAS)
A semantic model of types and machine instructions for proof-carrying code
Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
An indexed model of recursive types for foundational proof-carrying code
ACM Transactions on Programming Languages and Systems (TOPLAS)
Toward a foundational typed assembly language
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A Stratified Semantics of General References Embeddable in Higher-Order Logic
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
System Description: Teyjus - A Compiler and Abstract Machine Based Implementation of lambda-Prolog
CADE-16 Proceedings of the 16th International Conference on Automated Deduction: Automated Deduction
Machine Instruction Syntax and Semantics in Higher Order Logic
CADE-17 Proceedings of the 17th International Conference on Automated Deduction
Compiling with proofs
Logic in Computer Science: Modelling and Reasoning about Systems
Logic in Computer Science: Modelling and Reasoning about Systems
A Syntactic Approach to Foundational Proof-Carrying Code
Journal of Automated Reasoning
Typed machine language
Interactive Theorem Proving and Program Development
Interactive Theorem Proving and Program Development
The open verifier framework for foundational verifiers
TLDI '05 Proceedings of the 2005 ACM SIGPLAN international workshop on Types in languages design and implementation
Hi-index | 0.00 |
Proof-carrying code provides amechanismfor insuring that a host, or code consumer, can safely run code delivered by a code producer. The host specifies a safety policy as a set of axioms and inference rules. In addition to a compiled program, the code producer delivers a formal proof of safety expressed in terms of those rules that can be easily checked. Foundational proof-carrying code (FPCC) provides increased security and greater flexibility in the construction of proofs of safety. Proofs of safety are constructed from the smallest possible set of axioms and inference rules. For example, typing rules are not included. In our semantic approach to FPCC, we encode a semantics of types from first principles and the typing rules are proved as lemmas. In addition, we start from a semantic definition of machine instructions and safety is defined directly from this semantics. Since FPCC starts from basic axioms and low-level definitions, it is necessary to build up a library of lemmas and definitions so that reasoning about particular programs can be carried out at a higher level, and ideally, also be automated. We describe a high-level organization that involves Hoarestyle reasoning about machine code programs. This organization is presented using two running examples. The examples, as well as illustrating the above mentioned approach to organizing proofs, is designed to provide a tutorial introduction to a variety of facets of our FPCC approach. For example, it illustrates how to prove safety of programs that traverse input data structures as well as allocate new ones.