Results 1  10
of
17
ECC, an Extended Calculus of Constructions
, 1989
"... We present a higherorder calculus ECC which can be seen as an extension of the calculus of constructions [CH88] by adding strong sum types and a fully cumulative type hierarchy. ECC turns out to be rather expressive so that mathematical theories can be abstractly described and abstract mathematics ..."
Abstract

Cited by 91 (4 self)
 Add to MetaCart
(Show Context)
We present a higherorder calculus ECC which can be seen as an extension of the calculus of constructions [CH88] by adding strong sum types and a fully cumulative type hierarchy. ECC turns out to be rather expressive so that mathematical theories can be abstractly described and abstract mathematics may be adequately formalized. It is shown that ECC is strongly normalizing and has other nice prooftheoretic properties. An !\GammaSet (realizability) model is described to show how the essential properties of the calculus can be captured settheoretically.
Constructing Specification Morphisms
 Journal of Symbolic Computation
, 1993
"... This paper is part of a broader research program to explore a mechanizable model of software development based on algebraic specifications and specification morphisms. An algebraic specification (or simply a specification) defines a language and constrains its possible meanings via axioms and infere ..."
Abstract

Cited by 47 (8 self)
 Add to MetaCart
This paper is part of a broader research program to explore a mechanizable model of software development based on algebraic specifications and specification morphisms. An algebraic specification (or simply a specification) defines a language and constrains its possible meanings via axioms and inference rules. Specifications can be used to express many kinds of softwarerelated artifacts, including domain models (Srinivas(1991)), formal requirements (Astesiano and Wirsing (1987), Ehrig and Mahr (1990), Partsch (1990), Sannella and Tarlecki (1985)), programming languages (Broy et al. (1987), Goguen and Winkler (1988), Hoare (1989)), abstract data types (Goguen et al. (1978), Guttag and Horning (1978)), and abstract algorithms (Smith and Lowry (1990)). There has been much work on operations for constructing larger specifications from smaller specifications (Astesiano and Wirsing (1987), Burstall and Goguen (1977), Sannella and Tarlecki (1988)). A specification morphism translates the language of one specification into the language of another specification in a way that preserves theorems. Specification morphisms underlie several aspects of software development, including specification refine
A logic of events
, 2003
"... There is a wellestablished theory and practice for creating correctbyconstruction 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 l ..."
Abstract

Cited by 12 (8 self)
 Add to MetaCart
(Show Context)
There is a wellestablished theory and practice for creating correctbyconstruction 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
Knowledgebased synthesis of distributed systems using event structures
 In Proc. 11th Int. Conf. on Logic for Programming, Artificial Intelligence, and Reasoning (LPAR 2004), Lecture Notes in Computer Science
, 2005
"... To produce a program guaranteed to satisfy a given specification one can synthesize it from a formal constructive proof that a computation satisfying that specification exists. This process is particularly effective if the specifications are written in a highlevel language that makes it easy for de ..."
Abstract

Cited by 8 (4 self)
 Add to MetaCart
(Show Context)
To produce a program guaranteed to satisfy a given specification one can synthesize it from a formal constructive proof that a computation satisfying that specification exists. This process is particularly effective if the specifications are written in a highlevel language that makes it easy for designers to specify their goals. We consider a highlevel specification language that results from adding knowledge to a fragment of Nuprl specifically tailored for specifying distributed protocols, called event theory. We then show how highlevel knowledgebased programs can be synthesized from the knowledgebased specifications using a proof development system such as Nuprl. Methods of Halpern and Zuck [1992] then apply to convert these knowledgebased protocols to ordinary protocols. These methods can be expressed as heuristic transformation tactics in Nuprl. 1
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. Theexposition 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.
A Causal Logic of Events in Formalized Computational Type Theory ∗
"... We provide a logic for distributed computing that has the explanatory and technical power of constructive logics of computation. In particular, we establish a proof technology that supports correctbyconstruction programming based on the notion that concurrent processes can be extracted from proofs ..."
Abstract
 Add to MetaCart
We provide a logic for distributed computing that has the explanatory and technical power of constructive logics of computation. In particular, we establish a proof technology that supports correctbyconstruction programming based on the notion that concurrent processes can be extracted from proofs that specifications are achievable. 1
The MetaPRL Logical Programming Environment  Volume I
, 2001
"... This thesis is primarily about the design of formal programming environments for building large software systems. This work articulates two principles and uses them to guide the design, implementation, and study of a specific formal programming environment. First, design methods for large software s ..."
Abstract
 Add to MetaCart
This thesis is primarily about the design of formal programming environments for building large software systems. This work articulates two principles and uses them to guide the design, implementation, and study of a specific formal programming environment. First, design methods for large software systems will include multiple languages, methodologies, and refinement techniques that are suited to problem subdomains. This means that any formal system must provide the ability to define multiple logics, and it is by definition a logical framework. Second, the framework must provide the ability to express formal relations between logical theories to address the problem of system decomposition. This thesis also presents the the MetaPRL formal system. MetaPRL was built to provide a modular, abstract logical framework where multiple designs can be expressed and related. The MetaPRL design builds on our experience with logical frameworks and with structured programming concepts like inheritance and reuse to provide an efficient, highly abstract, logical machine. The contribution includes several parts. • The development of an untyped metalogic using explicit substitution. • The definition of a verydependent function type in the Nuprl type theory. • A system architecture for generic multilogical development. • A generic refiner that provides automation and enforcement for the multiple logical theories in logical environment. • A module system for logics and theories. • A generic distributed interactive theorem prover.
Two Lectures on Constructive Type Theory
, 2015
"... Main Goal: One goal of these two lectures is to explain how important ideas and problems from computer science and mathematics can be expressed well in constructive type theory and how proof assistants for type theory help us solve them. Another goal is to note examples of abstract mathematical idea ..."
Abstract
 Add to MetaCart
(Show Context)
Main Goal: One goal of these two lectures is to explain how important ideas and problems from computer science and mathematics can be expressed well in constructive type theory and how proof assistants for type theory help us solve them. Another goal is to note examples of abstract mathematical ideas currently not expressed well enough in type theory. The two lectures will address the following three specific questions related to this goal. Three Questions: One, what are the most important foundational ideas in computer science and mathematics that are expressed well in constructive type theory, and what concepts are more difficult to express? Two, how can proof assistants for type theory have a large impact on research and education, specifically in computer science, mathematics, and beyond? Three, what key ideas from type theory are students missing if they know only one of the modern type theories? The lectures are intended to complement the handson Nuprl tutorials by Dr. Mark Bickford that will introduce new topics as well as address these questions. The lectures refer to recent educational material posted on the PRL project web page, www.nuprl.org, especially the online article Logical Investigations, July 2014 on the front page of the web cite.
Proof Assistants and the Dynamic Nature of Formal Theories
, 2012
"... This article shows that theory exploration arises naturally from the need to progressively modify applied formal theories, especially those underpinning deployed systems that change over time or need to be attacktolerant. Such formal theories require us to explore a problem space with a proof assis ..."
Abstract
 Add to MetaCart
(Show Context)
This article shows that theory exploration arises naturally from the need to progressively modify applied formal theories, especially those underpinning deployed systems that change over time or need to be attacktolerant. Such formal theories require us to explore a problem space with a proof assistant and are naturally dynamic. The examples in this article are from our ongoing decadelong effort to formally synthesize critical components of modern distributed systems. Using the Nuprl proof assistant we created event logic and its protocol theories. I also mention the impact over this period of extensions to the constructive type theory implemented by Nuprl. One of them led to our solution of a long standing open problem in constructive logic. Proof exchange among theorem provers is promising for improving the “super tactics” that provide domain specific reasoners for our protocol theories. Both theory exploration and proof exchange illustrate the dynamic nature of applied formal theories built using modern proof assistants. These activities dispel the false impression that formal theories are rigid and brittle artifacts that become less relevant over time in a fast moving field like computer science.
The Need for Type Theory in Semantic Web Services
, 2005
"... INTRODUCTION My name is Rod Moten. I am a senior computer scientist at Bloomberg L.P., a financial market data company. Currently I'm involved in ontology and taxonomy development. Prior to coming to Bloomberg, I was an assistant professor at Colgate University. While on a sabbatical, I visite ..."
Abstract
 Add to MetaCart
INTRODUCTION My name is Rod Moten. I am a senior computer scientist at Bloomberg L.P., a financial market data company. Currently I'm involved in ontology and taxonomy development. Prior to coming to Bloomberg, I was an assistant professor at Colgate University. While on a sabbatical, I visited RPI. At RPI, I conducted research on using type theory to resolve semantic heterogeneity in multiagent systems [6, 7]. In this work, I showed how type theory could be used to implement a technique for automatically resolving semantic heterogeneity between software agents. The technique is an o#shoot of the proofsasprograms technique created in the 1970's [2, 1]. The proofsasprograms paradigm was developed by researchers in the formal methods community to develop software that was guaranteed to correctly implement its specification. The specifications were stated as logical assertions. If a proof could be constructed from the specification, then a program could be extracted from the p