Results 11  20
of
25
Facilitating Program Verification with Dependent Types
 In Proceedings of the International Conference on Software Engineering and Formal Methods
, 2003
"... The use of types in capturing program invariants is overwhelming in practical programming. The type systems in languages such as ML and Java scale convincingly to realistic programs but they are of relatively limited expressive power. In this paper, we show that the use of a restricted form of depen ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
The use of types in capturing program invariants is overwhelming in practical programming. The type systems in languages such as ML and Java scale convincingly to realistic programs but they are of relatively limited expressive power. In this paper, we show that the use of a restricted form of dependent types can enable us to capture many more program invariants such as memory safety while retaining practical typechecking. The programmer can encode program invariants with type annotations and then verify these invariants through static typechecking. Also the type annotations can serve as informative program documentation, which are mechanically verified and can thus be fully trusted. We argue with realistic examples that this restricted form of dependent types can significantly facilitate program verification as well as program documentation.
Representing Proof Transformations for Program Optimization
 IN PROCEEDINGS OF THE 12TH INTERNATIONAL CONFERENCE ON AUTOMATED DEDUCTION
, 1994
"... In the proofs as programs methodology a program is derived from a formal constructive proof. Because of the close relationship between proof and program structure, transformations can be applied to proofs rather than to programs in order to improve performance. We describe a method for implementing ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
In the proofs as programs methodology a program is derived from a formal constructive proof. Because of the close relationship between proof and program structure, transformations can be applied to proofs rather than to programs in order to improve performance. We describe a method for implementing transformations of formal proofs and show that it is applicable to the optimization of extracted programs. The method is based on the representation of derived logical rules in Elf, a logic programming language that gives an operational interpretation to the Edinburgh Logical Framework. It results in declarative implementations with a general correctness property that is verified automatically by the Elf type checking algorithm. We illustrate the technique by applying it to the problem of transforming a recursive function definition to obtain a tailrecursive form.
Specifying Interactions With Dependent Types
 In Workshop on subtyping and dependent types in programming
, 2000
"... this paper we consider how to express specications of interactions in dependent type theory. The results so far are modest, though we hope we have identied some key structures for describing contracts between independent agents, and shown how to dene them in a dependently typed framework. These are ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
this paper we consider how to express specications of interactions in dependent type theory. The results so far are modest, though we hope we have identied some key structures for describing contracts between independent agents, and shown how to dene them in a dependently typed framework. These are called below transition systems (2.2) and interaction systems (2.3). Both are coalgebras; transition systems for a functor Fam , and interaction systems for its composite with itself, Fam (Fam ). These structures seems to have interesting connections with predicate transformer semantics for imperative programs, as initiated by Dijkstra, and also with the renement calculus of Back and von Wright as described in their book [2]. We restrict attention to situations in which the system and its environment communicate by exchanging messages in strict alternation, as with the moves in a two player game.
Intensionality, Extensionality, and Proof Irrelevance in Modal Type Theory
 Pages 221–230 of: Symposium on Logic in Computer Science
, 2001
"... We develop a uniform type theory that integrates intensionality, extensionality, and proof irrelevance as judgmental concepts. Any object may be treated intensionally (subject only to #conversion), extensionally (subject also to ##conversion), or as irrelevant (equal to any other object at the sam ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
We develop a uniform type theory that integrates intensionality, extensionality, and proof irrelevance as judgmental concepts. Any object may be treated intensionally (subject only to #conversion), extensionally (subject also to ##conversion), or as irrelevant (equal to any other object at the same type), depending on where it occurs. Modal restrictions developed in prior work for simple types are generalized and employed to guarantee consistency between these views of objects. Potential applications are in logical frameworks, functional programming, and the foundations of firstorder modal logics.
A Comparison of Formalizations of the MetaTheory of a Language with Variable Bindings in Isabelle
 Supplemental Proceedings of the 14th International Conference on Theorem Proving in Higher Order Logics
, 2001
"... Abstract. Theorem provers can be used to reason formally about programming languages and there are various general methods for the formalization of variable binding operators. Hence there are choices for the style of formalization of such languages, even within a single theorem prover. The choice of ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
Abstract. Theorem provers can be used to reason formally about programming languages and there are various general methods for the formalization of variable binding operators. Hence there are choices for the style of formalization of such languages, even within a single theorem prover. The choice of formalization can affect how easy or difficult it is to do automated reasoning. The aim of this paper is to compare and contrast three formalizations (termed de Bruijn, weak HOAS and full HOAS) of a typical functional programming language. Our contribution is a detailed report on our formalizations, a survey of related work, and a final comparative summary, in which we mention a novel approach to a hybrid de Bruijn/HOAS syntax. 1
Program Extraction in a Logical Framework Setting
 IN PROCEEDINGS OF THE 5TH INTERNATIONAL CONFERENCE ON LOGIC PROGRAMMING AND AUTOMATED REASONING
, 1994
"... This paper demonstrates a method of extracting programs from formal deductions represented in the Edinburgh Logical Framework, using the Elf programming language. Deductive systems are given for the extraction of simple types from formulas of firstorder arithmetic and of calculus terms from n ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
This paper demonstrates a method of extracting programs from formal deductions represented in the Edinburgh Logical Framework, using the Elf programming language. Deductive systems are given for the extraction of simple types from formulas of firstorder arithmetic and of calculus terms from natural deduction proofs. These systems are easily encoded in Elf, yielding an implementation of extraction that corresponds to modified realizability. Because extraction is itself implemented as a set of formal deductive systems, some of its correctness properties can be partially represented and mechanically checked in the Elf language.
Decidability Extracted: Synthesizing ``CorrectbyConstruction'' Decision Procedures from Constructive Proofs
, 1998
"... The topic of this thesis is the extraction of efficient and readable programs from formal constructive proofs of decidability. The proof methods employed to generate the efficient code are new and result in clean and readable Nuprl extracts for two nontrivial programs. They are based on the use of ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
The topic of this thesis is the extraction of efficient and readable programs from formal constructive proofs of decidability. The proof methods employed to generate the efficient code are new and result in clean and readable Nuprl extracts for two nontrivial programs. They are based on the use of Nuprl's set type and techniques for extracting efficient programs from induction principles. The constructive formal theories required to express the decidability theorems are of independent interest. They formally circumscribe the mathematical knowledge needed to understand the derived algorithms. The formal theories express concepts that are taught at the senior college level. The decidability proofs themselves, depending on this material, are of interest and are presented in some detail. The proof of decidability of classical propositional logic is relative to a semantics based on Kleene's strong threevalued logic. The constructive proof of intuitionistic decidability presented here is the first machine formalization of this proof. The exposition reveals aspects of the Nuprl tactic collection relevant to the creation of readable proofs; clear extracts and efficient code are illustrated in the discussion of the proofs.
ATS/LF: a type system for constructing proofs as total functional programs
, 2004
"... The development of Applied Type System (ATS) [36, 31] stems from an earlier attempt to introduce dependent types into practical programming [38, 37]. While there is already a framework Pure Type System [4] (PTS) that offers a simple and general approach to designing and formalizing type systems, ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
The development of Applied Type System (ATS) [36, 31] stems from an earlier attempt to introduce dependent types into practical programming [38, 37]. While there is already a framework Pure Type System [4] (PTS) that offers a simple and general approach to designing and formalizing type systems,
Highlevel Proofs of Mathematical Programs Using Automatic Differentiation, Simplification, and some Common Sense
"... One problem in applying elementary methods to prove correctness of interesting scientific programs is the large discrepancy in level of discourse between lowlevel proof methods and the logic of scientific calculation, especially that used in a complex numerical program. The justification of an algo ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
One problem in applying elementary methods to prove correctness of interesting scientific programs is the large discrepancy in level of discourse between lowlevel proof methods and the logic of scientific calculation, especially that used in a complex numerical program. The justification of an algorithm typically relies on algebra or analysis, but the correctness of the program requires that the arithmetic expressions are written correctly and that iterations converge to correct values in spite of truncation of infinite processes or series and the commission of numerical roundoff errors. We hope to help bridge this gap by showing how we can, in some cases, state a highlevel requirement and by using a computer algebra system (CAS) demonstrate that a program satisfies that requirement. A CAS can contribute program manipulation, partial evaluation, simplification or other algorithmic methods. A novelty here is that we add to the usual list of techniques algorithm differentiation, a method already widely used in different contexts (usually optimization), to those used already for program proofs. We sketch a proof of a numerical program to compute sine, and display a related approach to a version of a Bessel function algorithm for J0(x) based on a recurrence.
Attributive Types for Proof Erasure ⋆
"... Abstract. Proof erasure plays an essential role in the paradigm of programming with theorem proving. In this paper, we introduce a form of attributive types that carry an attribute to determine whether expressions assigned such types are eligible for erasure before runtime. We formalize a type syst ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. Proof erasure plays an essential role in the paradigm of programming with theorem proving. In this paper, we introduce a form of attributive types that carry an attribute to determine whether expressions assigned such types are eligible for erasure before runtime. We formalize a type system to support this form of attributive types and then establish its soundness. In addition, we outline an extension of the developed type system with dependent types and present some examples to illustrate its use in practice. 1