Results 1  10
of
23
Guarded Recursive Datatype Constructors
, 2003
"... introduc e a notion of guarded rec ursive (g.r.) datatype c#w struc tors, generalizing the notion ofrec# rsive datatypes in func tional programming languages suc h as ML and Haskell. We address both theoret ic#t and prac# ic## issues resulted from this generalization. On one hand, we design a type s ..."
Abstract

Cited by 129 (10 self)
 Add to MetaCart
introduc e a notion of guarded rec ursive (g.r.) datatype c#w struc tors, generalizing the notion ofrec# rsive datatypes in func tional programming languages suc h as ML and Haskell. We address both theoret ic#t and prac# ic## issues resulted from this generalization. On one hand, we design a type system to formalize the notion of g.r. datatypec onstruc  tors and then prove the soundness of the type system. On the other hand, we present some signific ant applic ations (e.g., implementing objec ts, implementing stagedc omputation, etc# ) of g.r. datatype c# nstruc#S rs, arguing that g.r. datatypec onstruc torsc an have farreac hingc onsequenc es in programming. The mainc ontribution of the paper lies in the rec#I0 ition and then the formalization of a programming notion that is of both theoretic# l interest and prac tic# l use.
TemporalSafety Proofs for Systems Code
, 2002
"... We present a methodology and tool for verifying and certifying systems code. The veri cation is based on the lazyabstraction paradigm for intertwining the following three logical steps: construct a predicate abstraction from the code, model check the abstraction, and automatically re ne the a ..."
Abstract

Cited by 70 (9 self)
 Add to MetaCart
We present a methodology and tool for verifying and certifying systems code. The veri cation is based on the lazyabstraction paradigm for intertwining the following three logical steps: construct a predicate abstraction from the code, model check the abstraction, and automatically re ne the abstraction based on counterexample analysis. The certi cation is based on the proofcarrying code paradigm. Lazy abstraction enables the automatic construction of small proof certi cates. The methodology is implemented in Blast, the Berkeley Lazy Abstraction Software veri cation Tool. We describe our experience applying Blast to Linux and Windows device drivers. Given the C code for a driver and for a temporalsafety monitor, Blast automatically generates an easily checkable correctness certi cate if the driver satis es the speci cation, and an error trace otherwise.
Ordered Linear Logic and Applications
, 2001
"... This work is dedicated to my parents. Acknowledgments Firstly, and foremost, I would like to thank my principal advisor, Frank Pfenning, for his patience with me, and for teaching me most of what I know about logic and type theory. I would also like to acknowledge some useful discussions with Kevin ..."
Abstract

Cited by 36 (0 self)
 Add to MetaCart
This work is dedicated to my parents. Acknowledgments Firstly, and foremost, I would like to thank my principal advisor, Frank Pfenning, for his patience with me, and for teaching me most of what I know about logic and type theory. I would also like to acknowledge some useful discussions with Kevin Watkins which led me to simplify some of this work. Finally, I would like to thank my other advisor, John Reynolds, for all his kindness and support over the last five years. Abstract This thesis introduces a new logical system, ordered linear logic, which combines reasoning with unrestricted, linear, and ordered hypotheses. The logic conservatively extends (intuitionistic) linear logic, which contains both unrestricted and linear hypotheses, with a notion of ordered hypotheses. Ordered hypotheses must be used exactly once, subject to the order in which they were assumed (i.e., their order cannot be changed during the course of a derivation). This ordering constraint allows for logical representations of simple data structures such as stacks and queues. We construct ordered linear logic in the style of MartinL"of from the basic notion of a hypothetical judgement. We then show normalization for the system by constructing a sequent calculus presentation and proving cutelimination of the sequent system.
Practical RefinementType Checking
, 1997
"... Refinement types allow many more properties of programs to be expressed and statically checked than conventional type systems. We present a practical algorithm for refinementtype checking in a calculus enriched with refinementtype annotations. We prove that our basic algorithm is sound and comple ..."
Abstract

Cited by 34 (1 self)
 Add to MetaCart
Refinement types allow many more properties of programs to be expressed and statically checked than conventional type systems. We present a practical algorithm for refinementtype checking in a calculus enriched with refinementtype annotations. We prove that our basic algorithm is sound and complete, and show that every term which has a refinement type can be annotated as required by our algorithm. Our positive experience with an implementation of an extension of this algorithm to the full core language of Standard ML demonstrates that refinement types can be a practical program development tool in a realistic programming language. The required refinement type definitions and annotations are not much of a burden and serve as formal, machinechecked explanations of code invariants which otherwise would remain implicit. 1 Introduction The advantages of staticallytyped programming languages are well known, and have been described many times (e.g. see [Car97]). However, conventional ty...
Tabled HigherOrder Logic Programming
 In 20th International Conference on Automated Deduction
, 2003
"... Elf is a general metalanguage for the specification and implementation of logical systems in the style of the logical framework LF. Based on a logic programming interpretation, it supports executing logical systems and reasoning with and about them, thereby reducing the effort required for each ..."
Abstract

Cited by 26 (11 self)
 Add to MetaCart
Elf is a general metalanguage for the specification and implementation of logical systems in the style of the logical framework LF. Based on a logic programming interpretation, it supports executing logical systems and reasoning with and about them, thereby reducing the effort required for each particular logical system. The traditional logic programming paradigm is extended by replacing firstorder terms with dependently typed terms and allowing implication and universal quantification in the bodies of clauses. These higherorder features allow us to model concisely and elegantly conditions on variables and the discharge of assumptions which are prevalent in many logical systems. However, many specifications are not executable under the traditional logic programming semantics and performance may be hampered by redundant computation. To address these problems, I propose a tabled higherorder logic programming interpretation for Elf. Some redundant computation is eliminated by memoizing subcomputation and reusing its result later. If we do not distinguish different proofs for a property, then search based on tabled logic programming is complete and terminates for programs with bounded recursion. In this proposal, I present a prooftheoretical characterization for tabled higherorder logic programming. It is the basis of the implemented prototype for tabled logic programming interpreter for Elf. Preliminary experiments indicate that many more logical specifications are executable under the tabled semantics. In addition, tabled computation leads to more efficient execution of programs. The goal of the thesis is to demonstrate that tabled logic programming allows us to efficiently automate reasoning with and about logical systems in the logical f...
Metaprogramming through typeful code representation
 In Proceedings of the Eighth ACM SIGPLAN International Conference on Functional Programming
, 2003
"... By allowing the programmer to write code that can generate code at runtime, metaprogramming offers a powerful approach to program construction. For instance, metaprogramming can often be employed to enhance program efficiency and facilitate the construction of generic programs. However, metaprog ..."
Abstract

Cited by 22 (4 self)
 Add to MetaCart
By allowing the programmer to write code that can generate code at runtime, metaprogramming offers a powerful approach to program construction. For instance, metaprogramming can often be employed to enhance program efficiency and facilitate the construction of generic programs. However, metaprogramming, especially in an untyped setting, is notoriously errorprone. In this paper, we aim at making metaprogramming less errorprone by providing a type system to facilitate the construction of correct metaprograms. We first introduce some code constructors for constructing typeful code representation in which program variables are replaced with deBruijn indices, and then formally demonstrate how such typeful code representation can be used to support metaprogramming. The main contribution of the paper lies in recognition and then formalization of a novel approach to typed metaprogramming that is practical, general and flexible.
Termination and Reduction Checking in the Logical Framework
 IN WORKSHOP OF AUTOMATION OF PROOFS BY MATHEMATICAL INDUCTION
, 2000
"... ..."
Termination and Reduction Checking for HigherOrder Logic Programs
 In First International Joint Conference on Automated Reasoning (IJCAR
"... . In this paper, we present a syntaxdirected termination and reduction checker for higherorder logic programs. The reduction checker verifies parametric higherorder subterm orderings describing input and output relations. These reduction orderings are exploited during termination checking to ..."
Abstract

Cited by 13 (3 self)
 Add to MetaCart
. In this paper, we present a syntaxdirected termination and reduction checker for higherorder logic programs. The reduction checker verifies parametric higherorder subterm orderings describing input and output relations. These reduction orderings are exploited during termination checking to infer that a specified termination order holds. To reason about parametric higherorder subterm orderings, we introduce a deductive system as a logical foundation for proving termination. This allows the study of prooftheoretical properties, such as consistency, local soundness and completeness and decidability. We concentrate here on proving consistency of the presented inference system. The termination and reduction checker are implemented as part of the Twelf system and enables us to verify proofs by complete induction. 1 Introduction One of the central problems in verifying specifications and checking proofs about them is the need to prove termination. Several automated methods...
Implementing Cut Elimination: A Case Study of Simulating Dependent Types in Haskell
 In Proceedings of the 6th International Symposium on Practical Aspects of Declarative Languages
, 2004
"... Gentzen's Hauptsatz  cut elimination theorem  in sequent calculi reveals a fundamental property on logic connectives in various logics such as classical logic and intuitionistic logic. In this paper, we implement a procedure in Haskell to perform cut elimination for intuitionistic sequent ca ..."
Abstract

Cited by 12 (4 self)
 Add to MetaCart
Gentzen's Hauptsatz  cut elimination theorem  in sequent calculi reveals a fundamental property on logic connectives in various logics such as classical logic and intuitionistic logic. In this paper, we implement a procedure in Haskell to perform cut elimination for intuitionistic sequent calculus, where we use types to guarantee that the procedure can only return a cutfree proof of the same sequent when given a proof of a sequent that may contain cuts. The contribution of the paper is twofold. On the one hand, we present an interesting (and somewhat unexpected) application of the current type system of Haskell, illustrating through a concrete example how some typical use of dependent types can be simulated in Haskell. On the other hand, we identify several problematic issues with such a simulation technique and then suggest some approaches to addressing these issues in Haskell.
MultiLevel MetaReasoning with Higher Order Abstract Syntax
 Foundations of Software Science and Computation Structures, volume 2620 of Lecture Notes in Computer Science
, 2003
"... Abstract. Combining Higher Order Abstract Syntax (HOAS) and (co)induction is well known to be problematic. In previous work [1] we have described the implementation of a tool called Hybrid, within Isabelle HOL, which allows object logics to be represented using HOAS, and reasoned about using tactica ..."
Abstract

Cited by 12 (4 self)
 Add to MetaCart
Abstract. Combining Higher Order Abstract Syntax (HOAS) and (co)induction is well known to be problematic. In previous work [1] we have described the implementation of a tool called Hybrid, within Isabelle HOL, which allows object logics to be represented using HOAS, and reasoned about using tactical theorem proving and principles of (co)induction. Moreover, it is definitional, which guarantees consistency within a classical type theory. In this paper we describe how to use it in a multilevel reasoning fashion, similar in spirit to other metalogics such F Oλ ∆IN and Twelf. By explicitly referencing provability, we solve the problem of reasoning by (co)induction in presence of nonstratifiable hypothetical judgments, which allow very elegant and succinct specifications. We demonstrate the method by formally verifying the correctness of a compiler for (a fragment) of MiniML, following [10]. To further exhibit the flexibility of our system, we modify the target language with a notion of nonwellfounded closure, inspired by Milner & Tofte [19] and formally verify via coinduction a subject reduction theorem for this modified language. 1