Results 1  10
of
22
Semantic subtyping with an SMT solver
, 2010
"... We study a firstorder functional language with the novel combination of the ideas of refinement type (the subset of a type to satisfy a Boolean expression) and typetest (a Boolean expression testing whether a value belongs to a type). Our core calculus can express a rich variety of typing idioms; ..."
Abstract

Cited by 30 (1 self)
 Add to MetaCart
(Show Context)
We study a firstorder functional language with the novel combination of the ideas of refinement type (the subset of a type to satisfy a Boolean expression) and typetest (a Boolean expression testing whether a value belongs to a type). Our core calculus can express a rich variety of typing idioms; for example, intersection, union, negation, singleton, nullable, variant, and algebraic types are all derivable. We formulate a semantics in which expressions denote terms, and types are interpreted as firstorder logic formulas. Subtyping is defined as valid implication between the semantics of types. The formulas are interpreted in a specific model that we axiomatize using standard firstorder theories. On this basis, we present a novel typechecking algorithm able to eliminate many dynamic tests and to detect many errors statically. The key idea is to rely on an SMT solver to compute subtyping efficiently. Moreover, interpreting types as formulas allows us to call the SMT solver at runtime to compute instances of types.
A logical framework with dependently typed records
 In Proceedings of TLCA 2003, volume 2701 of LNCS
, 2003
"... ..."
Situation Semantics: the ontological balance sheet
, 2005
"... One of the important challenges facing NL semantics in the early 21st century is to theoretically underpin analysis and generation of conversational interaction. I start by considering certain requirements a semantic framework needs in order to be viable for this task, with reference to a benchmark ..."
Abstract

Cited by 12 (0 self)
 Add to MetaCart
One of the important challenges facing NL semantics in the early 21st century is to theoretically underpin analysis and generation of conversational interaction. I start by considering certain requirements a semantic framework needs in order to be viable for this task, with reference to a benchmark example. One fundamental requirement is the provision of an ontology which incorporates propositions, questions, and similar abstract entities. The main theme of this paper concerns the construction of such an ontology. I argue that Barwise and Perry’s approach to ontology—including its nonstandard trichotomy distinguishing between situations/events, situation types, and propositions—provides useful building blocks. I implement the construction using the type theoretic framework developed by Cooper (this journal).
A Bidirectional Refinement Type System for LF
, 2007
"... We present a system of refinement types for LF in the style of recent formulations where only canonical forms are welltyped. Both the usual LF rules and the rules for type refinements are bidirectional, leading to a straightforward proof of decidability of typechecking even in the presence of inte ..."
Abstract

Cited by 12 (5 self)
 Add to MetaCart
We present a system of refinement types for LF in the style of recent formulations where only canonical forms are welltyped. Both the usual LF rules and the rules for type refinements are bidirectional, leading to a straightforward proof of decidability of typechecking even in the presence of intersection types. Because we insist on canonical forms, structural rules for subtyping can now be derived rather than being assumed as primitive. We illustrate the expressive power of our system with several examples in the domain of logics and programming languages.
MetaPRL  A Modular Logical Environment
, 2003
"... MetaPRL is the latest system to come out of over twenty five years of research by the Cornell PRL group. While initially created at Cornell, MetaPRL is currently a collaborative project involving several universities in several countries. The MetaPRL system combines the properties of an interactive ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
(Show Context)
MetaPRL is the latest system to come out of over twenty five years of research by the Cornell PRL group. While initially created at Cornell, MetaPRL is currently a collaborative project involving several universities in several countries. The MetaPRL system combines the properties of an interactive LCFstyle tacticbased proof assistant, a logical framework, a logical programming environment, and a formal methods programming toolkit. MetaPRL is distributed under an opensource license and can be downloaded from http://metaprl.org/. This paper provides an overview of the system focusing on the features that did not exist in the previous generations of PRL systems.
Näıve computational type theory
 Proof and SystemReliability, Proceedings of International Summer School Marktoberdorf, July 24 to August 5, 2001, volume 62 of NATO Science Series III
, 2002
"... ..."
(Show Context)
Formalizing Abstract Algebra in Type Theory with Dependent Records
 Universitat Freiburg
, 2003
"... algebra suitable for a general reasoning. One of the most common ways to formalize abstract algebra is to make use of a module system to specify an algebra as a theory. However, this approach suffers from the fact that modules are usually not firstclass objects in the formal system. In this paper, ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
(Show Context)
algebra suitable for a general reasoning. One of the most common ways to formalize abstract algebra is to make use of a module system to specify an algebra as a theory. However, this approach suffers from the fact that modules are usually not firstclass objects in the formal system. In this paper, we develop a new approach based on the use of dependent record types. In our account, all algebraic structures are firstclass objects, with the natural subtyping properties due to record extension (for example, a group is a subtype of a monoid). Our formalization cleanly separates the axiomatization of the algebra from its typing properties, corresponding more closely to a textbook presentation. 1
Type Theoretical Foundations for Data Structures, Classes, and Objects
, 2004
"... In this thesis we explore the question of how to represent programming data structures in a constructive type theory. The basic data structures in programing languages are records and objects. Most known papers treat such data structure as primitive. That is, they add new primitive type constructors ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
In this thesis we explore the question of how to represent programming data structures in a constructive type theory. The basic data structures in programing languages are records and objects. Most known papers treat such data structure as primitive. That is, they add new primitive type constructors and supporting axioms for records and objects. This approach is not satisfactory. First of all it complicates a type theory a lot. Second, the validity of the new axioms is not easily established. As we will see the naive choice of axioms can lead to contradiction even in the simplest cases. We will show that records and objects can be defined in a powerful enough type theory. We will also show how to use these type constructors to define abstract data structure.
Generating Event Logics with HigherOrder Processes as Realizers
"... Our topic is broadening a practical ”proofsasprograms” method of program development to “proofsasprocesses”. We extend our previous results that implement proofsasprocesses for the standard model of asynchronous message passing computation to a much wider class of process models including the π ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Our topic is broadening a practical ”proofsasprograms” method of program development to “proofsasprocesses”. We extend our previous results that implement proofsasprocesses for the standard model of asynchronous message passing computation to a much wider class of process models including the πcalculus and other process algebras. Our first result is a general process model whose definition in type theory is interesting in itself both technically and foundationally. Process terms are type free lambdaterms. Typed processes are elements of a coinductive type. They are higherorder in that they can take processes as inputs and produce them as outputs. A second new result is a procedure to generate event structures over the general process model and then define event logics and event classes over these structures. Processes are abstract realizers for assertions in the event logics over them, and they extend the class of primitively realizable propositions built on the propositionsastypes principle. They also provide a basis for the third new result, showing when programmable event classes generate strong realizers that prevent logical interference as processes are synthesized.
Proof contexts with late binding
 In Typed Lambda Calculi and Applications, volume 3461 of LNCS
, 2005
"... Abstract. The Focal language (formerly FoC) allows one to incrementally build modules and to formally prove their correctness. In this paper, we present two formal semantics for encoding Focal constructions in the Coq proof assistant. The first one is implemented in the Focal compiler to have the ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
Abstract. The Focal language (formerly FoC) allows one to incrementally build modules and to formally prove their correctness. In this paper, we present two formal semantics for encoding Focal constructions in the Coq proof assistant. The first one is implemented in the Focal compiler to have the correctness of Focal libraries verified with the Coq proofchecker. The second one formalizes the Focal structures and their main properties as Coq terms (called mixDrecs). The relations between the two embeddings are examined in the last part of the paper. 1