Record types are an important tool for programming and are essential in objectoriented calculi. Dependent record types are proven to be very useful for program specification and verification. Unfortunately, all known embedding of the dependent record type in the type theory had some imperfections. In this paper we present a new type constructor, dependent intersection, i.e., the intersection of two types, where the second type may depend on elements of the first one (do not confuse it with the intersection of a family of types). This new type constructor allows us to define dependent records in a very simple way.

Proof systems for expressive type theories provide a foundation for the verification and synthesis of programs. But despite their successful application to numerous programming problems there remains an issue with scalability. Are proof environments capable of reasoning about large software systems? Can the support they offer be useful in practice? In this article we answer this question by showing how the Nuprl proof development system and its rich type theory have contributed to the design of reliable, high-performance networks by synthesizing optimized code for application configurations of the Ensemble group communication toolkit. We present a type-theoretical semantics of OCaml, the implementation language of Ensemble, and tools for automatically importing system code into the Nuprl system. We describe reasoning strategies for generating verifiably correct fast-path optimizations of application configurations that substantially reduce end-to-end latency in Ensemble. We also discuss briefly how to use Nuprl for checking configurations against specifications and for the design of reliable adaptive network protocols.

There is a well-established theory and practice for creating correct-by-construction functional programs by extracting them from constructive proofs of assertions of the form ∀x: A.∃y: B.R(x, y). There have been several efforts to extend this methodology to concurrent programs, say by using linear logic, but there is no practice and the results are limited. In this paper we define a logic of events that justifies the extraction of correct distributed processes from constructive proofs that system specifications are achievable, and we describe an implementation of an extraction process in the context of constructive type theory. We show that a class of message automata, similar to IO automata and to active objects, are realizers for this logic. We provide a relative consistency result for the logic. We show an example of protocol derivation in this logic, and show how to embed temporal logics such as T LA+ in the event logic. 1

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 LCF-style tactic-based proof assistant, a logical framework, a logical programming environment, and a formal methods programming toolkit. MetaPRL is distributed under an open-source 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.

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. BIOGRAPHICAL SKETCH Alexei Kopylov was born in Moscow State University on April 2, 1974. His parents were students in the Department of Mathematics and Mechanics there. First year of his life Alexei lived in a student dormitory in the main building of the Moscow State University. Then his parents moved to Chernogolovka, a cozy scientific town near Moscow. Alexei returned to Moscow State University as a student in 1991. Five years later he graduated from the Department of Mathematics and Mechanics and entered the graduate school of the same Department.

Abstract. Manifest fields in a type of modules are shown to be expressible in intensional type theory without strong extensional equality rules. These intensional manifest fields are made available with the help of coercive subtyping. It is shown that, for both Σ-types and dependent record types, the with-clause for expressing manifest fields can be introduced by means of the intensional manifest fields. This provides not only a higher-order module mechanism with ML-style sharing, but a powerful modelling mechanism in formalisation and verification of OO-style program modules. 1

This article uses the Internet as a starting point to illustrate universal aspects of complex systems throughout technology and biology. Complexity in most systems is driven by the need for robustness to uncertainty in their environments and component parts far more than by basic functionality. Protocols organize highly structured and complex modular hierarchies to achieve robustness, but also create fragilities to rare or neglected perturbations. We claim these are also the most important and universal features of complex systems. All of this complexity is largely hidden, deliberately creating the illusion of superficially simple systems, which encourages development of specious theories. We also discuss an emerging theoretical foundation for the Internet. The aim is to provide a framework for understanding both the successes and shortcomings of existing Internet technology, offer alternative protocols for identified problems, guide rational design for future evolution of ubiquitous networking, and suggest what new mathematics and technology will be needed for a useful, general theory of complex systems.

The basic concepts of type theory are fundamental to computer science, logic and mathematics. Indeed, the language of type theory connects these regions of science. It plays a role in computing and information science akin to that of set theory in pure mathematics. There are many excellent accounts of the basic ideas of type theory, especially at the interface of computer science and logic — specifically, in the literature of programming languages, semantics, formal methods and automated reasoning. Most of these are very technical, dense with formulas, inference rules, and computation rules. Here we follow the example of the mathematician Paul Halmos, who in 1960 wrote a 104-page book called Naïve Set Theory intended to make the subject accessible to practicing mathematicians. His book served many generations well. This article follows the spirit of Halmos ’ book and introduces type theory without recourse to precise axioms and inference rules, and with a minimum of formalism. I start by paraphrasing the preface to Halmos ’ book. The sections of this article follow his chapters closely. Every computer scientist agrees that every computer scientist must know some type theory; the disagreement begins in trying to decide how much is some. This article contains my partial answer to that question. The purpose of the article is to tell the beginning student of advanced computer science the basic type theoretic facts of life, and to do so with a minimum of philosophical discourse and logical formalism. The point throughout is that of a prospective computer scientist eager to study programming languages, or database systems, or computational complexity theory, or distributed systems or information discovery. In type theory, “naïve ” and “formal ” are contrasting words. The present treatment might best be described as informal type theory from a naïve point of view. The concepts are very general and very abstract; therefore they may

The paper develops a semantics for natural language interrogatives which identifies questions— the denotations of interrogatives—with propositional abstracts. The paper argues that a theory of Questions as Propositional Abstracts (QPA), is a simple, transparently implementable theory that has significant empirical coverage. However, until recently QPA has been abandoned in formal semantic treatments of questions, due to a number of significant problems QPA encountered when formulated within the type system of Montague Semantics. In recent work, Ginzburg and Sag provided a a situation theoretic implementation of QPA that succeeded in overcoming cerain of the original problems for QPA. However, Ginzburg and Sag’s proposal relied on a special purpose account of λ-abstraction, raising the question to what extent QPA can be sustained using standard notions of abstraction. In this paper such doubts are allayed by implementing QPA in a version of Type Theory that provides record types. These latter allow one to develop notions of simultaneous/vacuous abstraction with restrictions and an ontology with various ‘informational entities’. Moreover, the intrinsic polymorphism of this theory plays a crucial role in enabling the definition of a general type for questions, one of the main stumbling blocks for earlier versions of QPA. 1

This article follows the spirit of Halmos' book and introduces type theory without recourse to precise axioms and inference rules, and with a minimum of formalism. I start by paraphrasing the preface to Halmos' book. The sections of this article follow his chapters closely. Every computer scientist agrees that every computer scientist must know some type theory; the disagreement begins in trying to decide how much is some. This article contains my partial answer to that question. The purpose of the article is to tell the beginning student of advanced computer science the basic type theoretic facts of life, and to do so with a minimum of philosophical discourse and logical formalism. The point throughout is that of a prospective computer scientist eager to study programming languages, or database systems, or computational complexity theory, or distributed systems or information discovery