Results 11  20
of
29
ThirdOrder Matching in the Presence of Type Constructors
, 1994
"... We show that it is decidable whether a thirdorder matching problem in ! (an extension of the simply typed lambda calculus with type constructors) has a solution or not. We present an algorithm which, given such a problem, returns a solution for this problem if the problem has a solution and returns ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
We show that it is decidable whether a thirdorder matching problem in ! (an extension of the simply typed lambda calculus with type constructors) has a solution or not. We present an algorithm which, given such a problem, returns a solution for this problem if the problem has a solution and returns fail otherwise. We also show that it is undecidable whether a thirdorder matching problem in ! has a closed solution or not. 1 Introduction It is wellknown that type theory is a good basis for the implementation of proof checkers. Although there are various ways to use type theory for proof checking, they all exploit the fact that type theory provides a uniform way to represent and manipulate proofs, formulas and data types. The manmachine interaction of proof checking can be considerably improved if some kind of matching algorithm can be implemented for the terms of the underlying type theory. For if one wants to prove OE(t) for a certain formula OE and term t, and one already has a pr...
Pure type systems with corecursion on streams From finite to infinitary normalisation
 IN ICFP
, 2012
"... In this paper, we use types for ensuring that programs involving streams are wellbehaved. We extend pure type systems with a type constructor for streams, a modal operator next and a fixed point operator for expressing corecursion. This extension is called Pure Type Systems with Corecursion (CoPTS) ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
In this paper, we use types for ensuring that programs involving streams are wellbehaved. We extend pure type systems with a type constructor for streams, a modal operator next and a fixed point operator for expressing corecursion. This extension is called Pure Type Systems with Corecursion (CoPTS). The typed lambda calculus for reactive programs defined by Krishnaswami and Benton can be obtained as a CoPTS. CoPTS’s allow us to study a wide range of typed lambda calculi extended with corecursion using only one framework. In particular, we study this extension for the calculus of constructions which is the underlying formal language of Coq. We use the machinery of infinitary rewriting and formalize the idea of wellbehaved programs using the concept of infinitary normalization. We study the properties of infinitary weak and strong normalization for CoPTS’s. The set of finite and infinite terms is defined as a metric completion. We shed new light on the meaning of the modal operator by connecting the modality with the depth used to define the metric. This connection is the key to the proofs of infinitary weak and strong normalization.
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. The exposition 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.
Interpreting ChurchStyle Typed λCalculus in CurryStyle Type Assignment
, 1997
"... It is well known that there are problems with the labelled syntax in Churchstyle type assignment to lambdaterms, the syntax in which the types of bound variables are indicated, as in λx : # . M , since if #reduction is added then the ChurchRosser Theorem fails in general (although it has been p ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
It is well known that there are problems with the labelled syntax in Churchstyle type assignment to lambdaterms, the syntax in which the types of bound variables are indicated, as in λx : # . M , since if #reduction is added then the ChurchRosser Theorem fails in general (although it has been proved for some common systems of type assignment) . In this paper, the labelled syntax is interpreted in the standard syntax of Currystyle type assignment by means of a constant Label, so that λx : # . M is taken as an abbreviation for Label#(λx . M ). The constant Label can be defined as a closed term, so that the labelled syntax is ultimately interpreted in a syntax for which the ChurchRosser Theorem is known to hold for both #reduction and #reduction. This interpretation is carried through for three well known systems of type assignment: ordinary type assignment, the secondorder polymorphic typed lambdacalculus, and the calculus of constructions. These cases illustrate the general ...
Towards Normalization by Evaluation for the βηCalculus of Constructions
"... Abstract. We consider the Calculus of Constructions with typed betaeta equality and an algorithm which computes long normal forms. The normalization algorithm evaluates terms into a semantic domain, and reifies the values back to terms in normal form. To show termination, we interpret types as part ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Abstract. We consider the Calculus of Constructions with typed betaeta equality and an algorithm which computes long normal forms. The normalization algorithm evaluates terms into a semantic domain, and reifies the values back to terms in normal form. To show termination, we interpret types as partial equivalence relations between values and type constructors as operators on PERs. This models also yields consistency of the betaetaCalculus of Constructions. The model construction can be carried out directly in impredicative type theory, enabling a formalization in Coq. 1
Formalization and Reasoning in a Reflective Architecture
, 1995
"... This paper is concerned with developing a reflective architecture for formalizing and reasoning about entities that occur in the process of software development, such as specifications, theorems, programs, and proofs. The starting point is a syntactic extension of the type theory ECC . An encoding o ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
This paper is concerned with developing a reflective architecture for formalizing and reasoning about entities that occur in the process of software development, such as specifications, theorems, programs, and proofs. The starting point is a syntactic extension of the type theory ECC . An encoding of this object calculus within itself comprises the metalevel, and reflection principles are provided for switching between di#erent levels. These reflection principles are used to mix object and metalevel reasoning, to generate "standard" units by executing metaoperators, and to apply formal tactics that allow for abstraction from the base logic. 1 Introduction Formalizing artifacts of software development and software engineering activities that produce these artifacts is, according to [2], a central issue of # Proc. of the IJCAI'95 Workshop "On Reflection and Meta Level Architecture and their Application in AI". Editors: M. Ibrahim, P. Cointe, F. Cummins, F. Giunchiglia, and J. Male...
Internal Program Extraction in the Calculus of Inductive Constructions
 In 6th Argentinian Workshop in Theoretical Computer Science (WAIT'02), 31st JAIIO
, 2002
"... Based on the Calculus of Constructions extended with inductive definitions we present a Theory of Specifications with rules for simultaneously constructing programs and their correctness proofs. The theory contains types for representing specifications, whose corresponding notion of implementation i ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Based on the Calculus of Constructions extended with inductive definitions we present a Theory of Specifications with rules for simultaneously constructing programs and their correctness proofs. The theory contains types for representing specifications, whose corresponding notion of implementation is that of a pair formed by a program and a correctness proof. The rules of the theory are such that in implementations the program parts appear mixed together with the proof parts. A reduction relation performs the task of separating programs from proofs. Consequently, every implementation computes to a pair composed of a program and a proof of its correctness, and so the program extraction procedure is immediate. 1
Formalization Of Systems Of Algebras Using Dependent Record Types And Subtyping: An Example.
 In Proceedings of the 7th. Nordic workshop on Programming Theory, Gothenburg
, 1995
"... . We present an example of formalization of systems of algebras using an extension of MartinLof's theory of types with record types and subtyping. This extension is informally explained along the presentation of the example. We also provide code of the formalization as accepted by a type checker im ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
. We present an example of formalization of systems of algebras using an extension of MartinLof's theory of types with record types and subtyping. This extension is informally explained along the presentation of the example. We also provide code of the formalization as accepted by a type checker implemented for the extended theory. Introduction. Our starting point, to which we refer hereafter as type theory, is the formulation of MartinLof's set theory using the theory of types as logical framework [12, 13, 8]. In type theory it is possible to form families of types on a given type, and thus types can be formed by applying such families to individuals. Having families of types allows to introduce dependent function types, that is, types of functions whose output type depends on individuals of the input type. In addition to the functional types there are only ground types: the type Set of (inductively defined) sets and, for each set A, the type of the elements of A. In [14, 4], an ex...
An operational approach to program extraction in the Calculus of Constructions
 In International Workshop on Logic Based Program Development and Transformation (LOPSTR'02), LNCS
, 2002
"... The Theory of Specifications is an extension of the Calculus of Constructions where the specification of a problem, the derivation of a program, and its correctness proof, can all be done within the same formalism. An operational semantics describes the process of extracting a program from a pro ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
The Theory of Specifications is an extension of the Calculus of Constructions where the specification of a problem, the derivation of a program, and its correctness proof, can all be done within the same formalism. An operational semantics describes the process of extracting a program from a proof of its specification. This has several advantages: from the user's point of view, it simplifies the task of developing correct programs, since it is sufficient to know just one system in order to be able to specify, develop and prove the correction of a program; from the implementation point of view, the fact that the extraction procedure is part of the system allows to control in a finer way its interactions with the rest of the system. In this paper we continue the study of the Theory of Specifications and propose a solution to restore subject reduction and strong normalization. Counterexamples for subject reduction and strong normalization for this theory have been shown in [RS02].
Formalization of Algebraic Specification in the Development Language Deva
 KORSO: Methods, Languages, and Tools to Construct Correct Software, LNCS
, 1995
"... . We show how software development based on algebraic specification can formally be represented in the development language Deva. We have formalized essential parts of the algebraic specification language Spectrum and a semantic development relation. The use of such a representation is threefold: ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
. We show how software development based on algebraic specification can formally be represented in the development language Deva. We have formalized essential parts of the algebraic specification language Spectrum and a semantic development relation. The use of such a representation is threefold: It makes developments amenable to consistency checks by machine, it documents the development for human readers, and it makes explicit the correspondence of development steps and resulting proof obligations. 1 Introduction Formal software development necessitates generation and verification of large numbers of proofs. These proofs on one hand fulfill a similar role as proofs in mathematics: they provide insight and convince human readers of the correctness of the stated result. On the other hand, the number and technical nature of the proofs necessitate mechanical verification. Thus it is necessary to bridge the gap between detailed, machinecheckable, formal proofs and concise, readable, i...