Results 11  20
of
112
A finite axiomatization of inductiverecursive definitions
 Typed Lambda Calculi and Applications, volume 1581 of Lecture Notes in Computer Science
, 1999
"... Inductionrecursion is a schema which formalizes the principles for introducing new sets in MartinLöf’s type theory. It states that we may inductively define a set while simultaneously defining a function from this set into an arbitrary type by structural recursion. This extends the notion of an in ..."
Abstract

Cited by 42 (14 self)
 Add to MetaCart
Inductionrecursion is a schema which formalizes the principles for introducing new sets in MartinLöf’s type theory. It states that we may inductively define a set while simultaneously defining a function from this set into an arbitrary type by structural recursion. This extends the notion of an inductively defined set substantially and allows us to introduce universes and higher order universes (but not a Mahlo universe). In this article we give a finite axiomatization of inductiverecursive definitions. We prove consistency by constructing a settheoretic model which makes use of one Mahlo cardinal. 1
Applied Type System (extended abstract
 In postworkshop Proceedings of TYPES 2003
, 2004
"... Abstract. The framework Pure Type System (PTS) offers a simple and general approach to designing and formalizing type systems. However, in the presence of dependent types, there often exist some acute problems that make it difficult for PTS to accommodate many common realistic programming features s ..."
Abstract

Cited by 38 (13 self)
 Add to MetaCart
Abstract. The framework Pure Type System (PTS) offers a simple and general approach to designing and formalizing type systems. However, in the presence of dependent types, there often exist some acute problems that make it difficult for PTS to accommodate many common realistic programming features such as general recursion, recursive types, effects (e.g., exceptions, references, input/output), etc. In this paper, we propose a new framework Applied Type System (ATS) to allow for designing and formalizing type systems that can readily support common realistic programming features. The key salient feature of ATS lies in a complete separation between statics, in which types are formed and reasoned about, and dynamics, in which programs are constructed and evaluated. With this separation, it is no longer possible for a program to occur in a type as is otherwise allowed in PTS. We present not only a formal development of ATS but also mention some examples in support of using ATS as a framework to form type systems for practical programming. 1
Definitions by Rewriting in the Calculus of Constructions
, 2001
"... The main novelty of this paper is to consider an extension of the Calculus of Constructions where predicates can be defined with a general form of rewrite rules. ..."
Abstract

Cited by 36 (6 self)
 Add to MetaCart
The main novelty of this paper is to consider an extension of the Calculus of Constructions where predicates can be defined with a general form of rewrite rules.
An expressive, scalable type theory for certified code
 In ACM International Conference on Functional Programming
, 2002
"... Abstract We present the type theory LTT, intended to form a basis for typed target languages, providing an internal notion of logical proposition and proof. The inclusion of explicit proofs allows the type system to guarantee properties that would otherwise be incompatible with decidable type checki ..."
Abstract

Cited by 35 (4 self)
 Add to MetaCart
Abstract We present the type theory LTT, intended to form a basis for typed target languages, providing an internal notion of logical proposition and proof. The inclusion of explicit proofs allows the type system to guarantee properties that would otherwise be incompatible with decidable type checking. LTT also provides linear facilities for tracking ephemeral properties that hold only for certain program states. Our type theory allows for reuse of typechecking software by casting a variety of type systems within a single language. We provide additional reuse with a framework for modular development of operational semantics. This framework allows independent type systems and their operational semantics to be joined together, automatically inheriting the type safety properties of those individual systems.
Maude as a Formal MetaTool
 FM’99 — Formal Methods, World Congress on Formal Methods in the Development of Computing Systems
, 1999
"... Given the different perspectives from which a complex software system has to be analyzed, the multiplicity of formalisms is unavoidable. This poses two important technical challenges: how to rigorously meet the need to interrelate formalisms, and how to reduce the duplication of effort in tool a ..."
Abstract

Cited by 34 (13 self)
 Add to MetaCart
Given the different perspectives from which a complex software system has to be analyzed, the multiplicity of formalisms is unavoidable. This poses two important technical challenges: how to rigorously meet the need to interrelate formalisms, and how to reduce the duplication of effort in tool and specification building across formalisms. These challenges could be answered by adequate formal metatools that, when given the specification of a formal inference system, generate an efficient inference engine, and when given a specification of two formalisms and a translation, generate an actual translator between them. Similarly, module composition operations that are logicindependent, but that at present require costly implementation efforts for each formalism, could be provided for logics in general by module algebra generator metatools. The foundations of metatools of this kind can be based on a metatheory of general logics. Their actual design and implementation can be based on appropriate logical frameworks having efficient implementations. This paper explains how the reflective logical framework of rewriting logic can be used, in conjunction with an efficient reflective implementation such as the Maude language, to design formal metatools such as those described above. The feasibility of these ideas and techniques has been demonstrated by a number of substantial experiments in which new formal tools and new translations between formalisms, efficient enough to be used in practice, have been generated. 1
Constructions, Inductive Types and Strong Normalization
, 1993
"... This thesis contains an investigation of Coquand's Calculus of Constructions, a basic impredicative Type Theory. We review syntactic properties of the calculus, in particular decidability of equality and typechecking, based on the equalityasjudgement presentation. We present a settheoretic notio ..."
Abstract

Cited by 31 (2 self)
 Add to MetaCart
This thesis contains an investigation of Coquand's Calculus of Constructions, a basic impredicative Type Theory. We review syntactic properties of the calculus, in particular decidability of equality and typechecking, based on the equalityasjudgement presentation. We present a settheoretic notion of model, CCstructures, and use this to give a new strong normalization proof based on a modification of the realizability interpretation. An extension of the core calculus by inductive types is investigated and we show, using the example of infinite trees, how the realizability semantics and the strong normalization argument can be extended to nonalgebraic inductive types. We emphasize that our interpretation is sound for large eliminations, e.g. allows the definition of sets by recursion. Finally we apply the extended calculus to a nontrivial problem: the formalization of the strong normalization argument for Girard's System F. This formal proof has been developed and checked using the...
General recursion via coinductive types
 Logical Methods in Computer Science
"... Vol. 1 (2:1) 2005, pp. 1–28 ..."
Inductionrecursion and initial algebras
 Annals of Pure and Applied Logic
, 2003
"... 1 Introduction Inductionrecursion is a powerful definition method in intuitionistic type theory in the sense of Scott ("Constructive Validity") [31] and MartinL"of [17, 18, 19]. The first occurrence of formal inductionrecursion is MartinL"of's definition of a universe `a la T ..."
Abstract

Cited by 28 (11 self)
 Add to MetaCart
1 Introduction Inductionrecursion is a powerful definition method in intuitionistic type theory in the sense of Scott ("Constructive Validity") [31] and MartinL"of [17, 18, 19]. The first occurrence of formal inductionrecursion is MartinL"of's definition of a universe `a la Tarski [19], which consists of a set U
ConstraintBased Type Inference for Guarded Algebraic Data Types
, 2003
"... Guarded algebraic data types, which subsume the concepts known in the literature as indexed types, guarded recursive datatype constructors, and phantom types, and are closely related to inductive types, have the distinguishing feature that, when typechecking a function defined by cases, every branch ..."
Abstract

Cited by 25 (3 self)
 Add to MetaCart
Guarded algebraic data types, which subsume the concepts known in the literature as indexed types, guarded recursive datatype constructors, and phantom types, and are closely related to inductive types, have the distinguishing feature that, when typechecking a function defined by cases, every branch must be checked under di#erent typing assumptions. This mechanism allows exploiting the presence of dynamic tests in the code to produce extra static type information.
A module calculus for Pure Type Systems
, 1996
"... Several proofassistants rely on the very formal basis of Pure Type Systems. However, some practical issues raised by the development of large proofs lead to add other features to actual implementations for handling namespace management, for developing reusable proof libraries and for separate verif ..."
Abstract

Cited by 24 (3 self)
 Add to MetaCart
Several proofassistants rely on the very formal basis of Pure Type Systems. However, some practical issues raised by the development of large proofs lead to add other features to actual implementations for handling namespace management, for developing reusable proof libraries and for separate verification of distincts parts of large proofs. Unfortunately, few theoretical basis are given for these features. In this paper we propose an extension of Pure Type Systems with a module calculus adapted from SMLlike module systems for programming languages. Our module calculus gives a theoretical framework addressing the need for these features. We show that our module extension is conservative, and that type inference in the module extension of a given PTS is decidable under some hypotheses over the considered PTS.