Results 11  20
of
26
On Coherence in Computer Algebra
, 1993
"... Modern computer algebra systems (e. g. AXIOM) support a rich type system including parameterized data types and the possibility of implicit coercions between types. In such a type system it will be frequently the case that there are different ways of building coercions between types. An importa ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
Modern computer algebra systems (e. g. AXIOM) support a rich type system including parameterized data types and the possibility of implicit coercions between types. In such a type system it will be frequently the case that there are different ways of building coercions between types. An important requirement is that all coercions between two types coincide, a property which is called coherence. We will prove a coherence theorem for a formal type system having several possibilities of coercions covering many important examples. Moreover, we will give some informal reasoning why the formally defined restrictions can be satisfied by an actual system.
Refinement Types for Logical Frameworks
, 2010
"... The logical framework LF and its metalogic Twelf can be used to encode and reason about a wide variety of logics, languages, and other deductive systems in a formal, machinecheckable way. Recent studies have shown that MLlike languages can profitably be extended with a notion of subtyping called r ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
The logical framework LF and its metalogic Twelf can be used to encode and reason about a wide variety of logics, languages, and other deductive systems in a formal, machinecheckable way. Recent studies have shown that MLlike languages can profitably be extended with a notion of subtyping called refinement types. A refinement type discipline uses an extra layer of term classification above the usual type system to more accurately capture certain properties of terms. I propose that adding refinement types to LF is both useful and practical. To support the claim, I exhibit an extension of LF with refinement types called LFR, work out important details of its metatheory, delineate a practical algorithm for refinement type reconstruction, and present several case studies that highlight the utility of refinement types for formalized mathematics. In the end I find that refinement types and LF are a match made in heaven: refinements enable many rich new modes of expression, and the simplicity of
Elaborating Intersection and Union Types
"... Designing and implementing typed programming languages is hard. Every new type system feature requires extending the metatheory and implementation, which are often complicated and fragile. To ease this process, we would like to provide general mechanisms that subsume many different features. In mode ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
Designing and implementing typed programming languages is hard. Every new type system feature requires extending the metatheory and implementation, which are often complicated and fragile. To ease this process, we would like to provide general mechanisms that subsume many different features. In modern type systems, parametric polymorphism is fundamental, but intersection polymorphism has gained little traction in programming languages. Most practical intersection type systems have supported only refinement intersections, which increase the expressiveness of types (more precise properties can be checked) without altering the expressiveness of terms; refinement intersections can simply be erased during compilation. In contrast, unrestricted intersections increase the expressiveness of terms, and can be used to encode diverse language features, promising an economy of both theory and implementation. We describe a foundation for compiling unrestricted intersection and union types: an elaboration type system that generates ordinary λcalculus terms. The key feature is a Forsythelike merge construct. With this construct, not all reductions of the source program preserve types; however, we prove that ordinary callbyvalue evaluation of the elaborated program corresponds to a typepreserving evaluation of the source program. We also describe a prototype implementation and applications of unrestricted intersections and unions: records, operator overloading, and simulating dynamic typing. 1.
Semantic Predicate Types and Approximation for Classbased Object Oriented Programming
"... Abstract. We define a small functional calculus that expresses classbased object oriented features and is modelled on the similar calculi of Featherweight Java [34] and Middleweight Java [15], which are ultimately based upon the Java programming language. We define a predicate system, similar to th ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
Abstract. We define a small functional calculus that expresses classbased object oriented features and is modelled on the similar calculi of Featherweight Java [34] and Middleweight Java [15], which are ultimately based upon the Java programming language. We define a predicate system, similar to the one defined in [10], and show subject reduction and expansion, and argue that program analysis systems can be built on top of this system. Generalising the concept of approximant from the Lambda Calculus, we show that all expressions that we can assign a predicate to have an approximant that satisfies the same predicate. From this, a characterisation of (head)normalisation follows. 1
Unification in a λCalculus with Intersection Types
"... We propose related algorithms for unification and constraint simplification in !& , a refinement of the simplytyped λcalculus with subtypes and bounded intersection types. !& is intended as the basis of a logical framework in order to achieve more succinct and declarative axiomatizations o ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
We propose related algorithms for unification and constraint simplification in !& , a refinement of the simplytyped λcalculus with subtypes and bounded intersection types. !& is intended as the basis of a logical framework in order to achieve more succinct and declarative axiomatizations of deductive systems than possible with the simplytyped λcalculus. The unification and constraint simplification algorithms described here lay the groundwork for a mechanization of such frameworks as constraint logic programming languages and theorem provers.
Intersection Types, λmodels, and Böhm Trees
"... This paper is an introduction to intersection type disciplines, with the aim of illustrating their theoretical relevance in the foundations of λcalculus. We start by describing the wellknown results showing the deep connection between intersection type systems and normalization properties, i.e. ..."
Abstract
 Add to MetaCart
This paper is an introduction to intersection type disciplines, with the aim of illustrating their theoretical relevance in the foundations of λcalculus. We start by describing the wellknown results showing the deep connection between intersection type systems and normalization properties, i.e., their power of naturally characterizing solvable, normalizing, and strongly normalizing pure λterms. We then explain the importance of intersection types for the semantics of λcalculus, through the construction of filter models and the representation of algebraic lattices. We end with an original result that shows how intersection types also allow to naturally characterize tree representations of unfoldings of λterms (Böhm trees).
Thesis Proposal: Refinement Types for LF
, 2008
"... The logical framework LF and its implementation as the Twelf metalogic provide both a practical system and a proven methodology for representing deductive systems and their metatheory in a machinecheckable way. An extension of LF with refinement types provides a convenient means for representing ce ..."
Abstract
 Add to MetaCart
The logical framework LF and its implementation as the Twelf metalogic provide both a practical system and a proven methodology for representing deductive systems and their metatheory in a machinecheckable way. An extension of LF with refinement types provides a convenient means for representing certain kinds of judgemental inclusions in an intrinsic manner. I propose to carry out such an extension in full, adapting as much of the Twelf metatheory engine as possible to the new system, and I intend to argue that the extension is both useful and practical. 1
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.
Refinement Type Checking
, 2003
"... Software development is a difficult and error prone task. Experience with programming languages with strong static type systems indicates that these type systems catch a large proportion of common errors at compile time. Given this success, it is natural to ask: can we capture and check more of the ..."
Abstract
 Add to MetaCart
(Show Context)
Software development is a difficult and error prone task. Experience with programming languages with strong static type systems indicates that these type systems catch a large proportion of common errors at compile time. Given this success, it is natural to ask: can we capture and check more of the intended properties of programs? In this dissertation I describe the development of an extension of the programming language Standard ML which allows many common program invariants to be expressed and checked. This extension is based on refinement types, which combine aspects of standard type systems with mechanisms such as regular grammars, subtyping and intersection types in order to capture some detailed program properties. I also present a number of extensions to previous work on refinement types which were required to support this development. Firstly, I present a new form of intersection types which are suitable for languages with callbyvalue effects, such as Standard ML. Secondly, I present a new approach to checking refinementtype correctness which is based on bidirectional checking, and which avoids previous difficulties with refinementtype inference. Thirdly, I present an extension of refinement types to languages with sequential pattern matching, such as Standard ML. 1