 Home  - Lambda_Calculus - Simply Typed Lambda Calculus
 Images Newsgroups
 Page 1     1-60 of 60    1

1. Simply Typed Lambda Calculus - Wikipedia, The Free Encyclopedia
The word simple types is also used to refer to extensions of the simply typed lambda calculus such as products, coproducts or natural numbers (System T) or
http://en.wikipedia.org/wiki/Simply_typed_lambda_calculus
var wgNotice = ""; var wgNoticeLocal = ""; var wgNoticeLang = "en"; var wgNoticeProject = "wikipedia";
##### Simply typed lambda calculus
Jump to: navigation search The simply typed lambda calculus ) is a typed lambda calculus whose only connective is (function type). This makes it the canonical, and in many ways simplest, example of a typed lambda calculus. The word simple types is also used to refer to extensions of the simply typed lambda calculus such as products coproducts or natural numbers (System T) or even full recursion (like PCF ). In contrast, systems which introduce polymorphic types (like System F ) or dependent types (like the Logical Framework ) are not considered simply typed . The simply typed lambda calculus was originally introduced by Alonzo Church in 1940 as an attempt to avoid paradoxical uses of the untyped lambda calculus
##### edit Types
The types of the simply typed lambda calculus are constructed from base types (or type variables) , and given types we can construct . Church used only two base types o for the type of propositions and for the type of individuals. Frequently the calculus with only one base type, usually

2. Notes On Simply Typed Lambda Calculus
These notes provide an introduction to lambdacalculi, specifically the simply typed lambda calculus. The first half of the notes gives a fairly thorough
http://www.lfcs.inf.ed.ac.uk/reports/98/ECS-LFCS-98-381/
Home
##### Notes on Simply Typed Lambda Calculus
Ralph Loader Abstract: These notes provide an introduction to lambda-calculi, specifically the simply typed lambda calculus. The first half of the notes gives a fairly thorough introduction to fairly traditional and fundamental results about lambda-calculi. The second half gives a detailed, quantitative analysis of the simply typed lambda calculus. ECS-LFCS-98-381 This report is available in the following formats:

3. Substraction Not Definable In Simply Typed Lambda Calculus | Shin-Cheng Mu
Substraction not Definable in simply typed lambda calculus. Written on June 21, 2007. I probably wrote this a couple of years ago when I was studying
http://www.iis.sinica.edu.tw/~scm/2007/substraction-not-definable-in-simply-type
@import url( http://www.iis.sinica.edu.tw/~scm/wp/wp-content/themes/basic2col-20/style.css ); @import url( http://www.iis.sinica.edu.tw/~scm/wp/wp-content/themes/basic2col-20/custom/custom.css); Content View menu
##### Substraction not Definable in Simply Typed Lambda Calculus
Written on June 21, 2007 I probably wrote this a couple of years ago when I was studying polymorphic types. What happens if we have only monomorphic type when we define church numerals? Let us represent church numerals by the type (a -> a) -> a -> a for some monomorphic a > import Prelude hiding (succ, pred) > type N a = (a -> a) -> a -> a Zero and successor can still be defined. Their values do not matter. > zero :: N a > zero = error "" > succ :: N a -> N a > succ = error "" Also assume we have pairs predefined: > pair a b = (a,b) We can even define primitive recursion, only that it does not have the desired type: primrec :: (N -> b -> b) -> b -> N -> b Instead we get the type below: Therefore, predecessor does not get the type pred :: N a -> N a
we want. Instead we have:

4. Simply Easy! (An Implementation Of A Dependently Typed Lambda Calculus) | Lambda
In fact, our implementation is almost as easy as an implementation of the simply typed lambda calculus, which we emphasize by discussing the modifications
http://lambda-the-ultimate.org/node/2340
@import "misc/drupal.css"; @import "themes/chameleon/ltu/style.css";
##### Lambda the Ultimate
Home Feedback FAQ ... Archives
Home forums LtU Forum
##### Simply Easy! (An Implementation of a Dependently Typed Lambda Calculus)
Simply Easy! (An Implementation of a Dependently Typed Lambda Calculus)
Andres LÂ¶h, Conor McBride and Wouter Swierstra We present an implementation in Haskell of a dependently-typed lambda calculus that can be used as the core of a programming language. We show that a dependently-typed lambda calculus is no more difficult to implement than other typed lambda calculi. In fact, our implementation is almost as easy as an implementation of the simply typed lambda calculus, which we emphasize by discussing the modifications necessary to go from one to the other. We explain how to add data types and write simple programs in the core language, and discuss the steps necessary to build a full-fledged programming language on top of our simple core. By Greg Buchholz LtU Forum previous forum topic next forum topic ... other blogs
##### Comment viewing options
Flat list - collapsed Flat list - expanded Threaded list - collapsed Threaded list - expanded Date - newest first Date - oldest first 10 comments per page 30 comments per page 50 comments per page 70 comments per page 90 comments per page 150 comments per page 200 comments per page Select your preferred way to display the comments and click "Save settings" to activate your changes.

 5. Findings:@Everything2.com If you Log in you could create a simply typed lambda calculus node. If you don t already have an account, you can Create A New User.http://everything2.com/index.pl?node=simply typed lambda calculus

6. Masterclass Typed Lambda Calculus
Introduction to Lambda Calculus. Lecture notes BarendregtBarendsen. 2. simply typed lambda calculus Forthcoming book on typed lambda calculus, Part I.
http://www.cs.ru.nl/~henk/Masterclass.html
##### by Henk Barendregt assisted by Wil Dekkers and Venanzio Capretta
Fall Semester 2006, Wednesdays 10.00-13.00. Radboud University, Huygens Building 3.054, Toernooiveld 1, Nijmegen Behind the content of the lectures the numbers refer to the references below. 20.09.2006 Week 1 Excercises Untyped theory: conversion, reduction, Church numerals, A_+, A_*, A_exp. (5: Sct. 2.2 Typed theory: Typing a la Curry (1: Ch. 5 Sct. 1.1 27.09.2006 Week 2 Excercises Untyped theory: Representing arbitrary computable functions (5: Sct. 2.2 ). Fixed-points. (5: Sct. 2.1 Typed theory: Typing algorithm. (2: ; it is less difficult than it looks!) Inhabitation algorithm for typing a la Curry (2: Sct. 1.2 04.10.2006 Week 3 Excercises Untyped theory: eta-reduction (2: ). Coding and reflection (4: Sct. 5 Typed theory: eta-expansion (2: Sct. 1.2 11.10.2006 Week 4 test 1 Untyped theory: second fixed-point theorem (6: Thm. 6.5.9), Scott's theorem (6: Thm. 6.6.2); Church-Rosser theorem (1: Ch 4 Typed theory: Church typed terms. (2: Sct 1.1

7. LAMP - Foundations Of Software, Ex.3: Simply Typed Lambda Calculus
Exercise 3 simply typed lambda calculus. Hand in November 2nd (2 weeks). Update The grammar has been updated to allow for syntactic sugar for numeric
http://lamp.epfl.ch/teaching/foundations_of_software/exercises/3-typed/
##### Foundations of Software 2007-2008
• franÂ§ais english EPFL LAMP Teaching Foundations of Software Exercise 3
##### Summary
• Scala API Scala reference
##### Exercise 3: Simply Typed Lambda Calculus
Hand in: November 2 nd (2 weeks). Update: The grammar has been updated to allow for syntactic sugar for numeric literals. In this exercise, we reuse the combinator parsing library introduced in exercise 1 The provided framework is self-contained and can be downloaded as zip
##### Assignment
previous assignment let and pairs , which we'll add later. It might be a good idea to start implementing this language first, and later add the rest. t "true" true value "false" false value "if" t "then" t "else" t if numericLit integer "pred" t predecessor "succ" t successor "iszero" t iszero x variable abstraction t t application (left associative) numericLiteral numeric literal "(" t ")" v values "true" "false" nv numeric value abstraction value nv numeric values "succ" nv Note: As in the first assignment, we add syntactic sugar for numeric literals. They are desugarized to the corresponding sequence of

 8. IngentaConnect Ordinals And Ordinal Functions Representable In The Simply Typed We define ordinal representations in the simply typed lambda calculus, and consider the ordinal functions representable with respect to these notations.http://www.ingentaconnect.com/content/els/01680072/1999/00000097/00000001/art000

9. Simply Typed Lambda Calculus With First-class Environments
simply typed lambda calculus with firstclass environments. Shin-ya Nishizaki. Source Publ. Res. Inst. Math. Sci. Volume 30, Number 6 (1994), 1055-1121.
http://projecteuclid.org/handle/euclid.prims/1195164948
Log in RSS Title Author(s) Abstract Subject Keyword All Fields FullText more options
• Home Browse Search ... next
##### Simply typed lambda calculus with first-class environments
Shin-ya Nishizaki Source: Publ. Res. Inst. Math. Sci. Volume 30, Number 6 (1994), 1055-1121. Primary Subjects: Secondary Subjects: Full-text: Access granted (open access) PDF File (4403 KB) Links and Identifiers Permanent link to this document: http://projecteuclid.org/euclid.prims/1195164948 Mathematical Reviews number (MathSciNet): Zentralblatt Math identifier: back to Table of Contents
##### References
 MIT Scheme Reference Manual, MIT.  Abelson, H. and Sussman, G. J., Structure and Interpretation of Computer Programs, The MIT Press, 1985. Zentralblatt MATH:  Curien, P-L., An abstract framework for environment machines, Theoretical Computer Science, 82 (1991), 389-402. Mathematical Reviews (MathSciNet): Zentralblatt MATH:  Curien, P-L., Categorical combinators, Information and Control, 69 (1986), 188-254. Mathematical Reviews (MathSciNet): Zentralblatt MATH:  Curien, P-L., Categorical combinators, sequential algorithms, and functional programming, Birkhauser, second edition, 1993.

10. MainFrame: The Lambda-calculus, Combinatory Logic, And Type Systems
The eight systems at the vertices of the cube are obtained by extending the simply typed lambda calculus ( lambda fun ) at the origin of the cube along one
http://rbjones.com/rbjpub/logic/cl/cl017.htm
##### Overview:
Three interrelated topics at the heart of logic and computer science. The -Calculus A pure calculus of functional abstraction and function application, with applications throughout logic and computer science. Types The -calculus is good tool for exploring type systems, invaluable both in the foundations of mathematics and for practical programming languages. Pure Type Systems A further generalisation and systematic presentation of the class of type systems found in the -cube. Combinators Combinatory logic shows that bound variables can be eliminated without loss of expressiveness. It has applications both in the foundations of mathematics and in the implementation of functional programming languages. Programming Languages The connections between the lambda-calculus and programming languages are diverse and pervasive. Type systems are an important aspect of programming language design. The -cube A graphical presentation of the relationship between combinatory logic, lambda calculi and related logical systems. The -cube A graphical presentation of the relationship between various typed -calculi, illuminating the structure of Coquand's Calculus of Constructions.

11. Typed Lambda Calculi Publications
We first illustrate the method on the elementary example of simply typed lambda calculus and then we show how to extend it to a more expressive dependent
http://www.math.unipd.it/~silvio/PublicationsLC.html
##### Type lambda Calculi
U. Solitro, S. Valentini, Toward Typed lambda-calculi for Linear Logic, proceeding of "The Third Italian Conference on theoretical Computer Science" (ed. Bertoni, Bshm, Miglioli), World Scientific, Mantova 1989, pp. 413-424. Abstract: In this paper it is studied the problem of stating a Curry-Howard isomorphism for Girard's Linear Logic. Two solutions are proposed: one for the intuitionistic variant of the logic and one for a subsytem of the logic which includes the multiplicative and exponential connectives. Different calculi have been developed for the two cases.
S. Valentini, The judgement calculus for Intuitionistic Linear Logic: proof theory and semantics, Abstract: In this paper I propose a new set of rules for a judgement calculus, i.e. a typed lambda calculus, based on Intuitionistic Linear Logic; these rules ease the problem of defining a suitable mathematical semantics. A proof of the canonical form theorem for this new system is given: it assures, beside the consistency of the calculus, the termination of the evaluation process of every well-typed element. The definition of the mathematical semantics and a completeness theorem, that turns out to be a representation theorem, follow. This semantics is the basis to obtain a semantics for the evaluation process of every well-typed program.
U. Solitro, S. Valentini

 12. STLC Staged Interpreter A dependently typed staged interpreter for simply typed lambda calculus. Introduction. STLC is an implementation of the language we develop in this paper.http://www.dcs.st-and.ac.uk/~eb/STLC/

13. Mathematician's Professional Homepage, Detail Information
S. Ghilezan and V. Kuncak Reducibility method in simply typed lambda calculus, Novi Sad Journal of Mathematics 31 (2001) 2732.
http://imft.ftn.ns.ac.yu/~silvia/research/publications.html

General Information

Research

Teaching

News and Miscellaneous
...
HOME
##### List of publications
• M.Dezani-Ciancaglini, S. Ghilezan, J. Pantovic, D. Varaca: Security types for dynamic web data Theoretical Computer Science (to appear).
• H. Herbelin and S. Ghilezan: An approach to call-by-name delimited continuations , The 35th Annual ACM SIGPLAN SIGACT Symposium on Principles of Programming Languages POPL 2008 San Francisco, USA, January 2008.
• D. Dougherty, S. Ghilezan and P. Lescanne: Characterizing strong normalization in the Curien-Herbelin symmetric lambda calculus: extending the Coppo-Dezani heritage, Theoretical Computer Science (special issue Festschrift Coppo, Dezani, Ronchi, eds S. Berardi, U de' Liquoro) (to appear).
• S. Ghilezan, J. Pantovic and J. Zunic: Separating Points by Parallel Hyperplanes Characterization Problem, IEEE Transactions of Neural Networks vol. 18 no. 5 (2007) 1356-1363.
• M.Dezani-Ciancaglini, S. Ghilezan and J. Pantovic:

14. Simply Typed Lambda Calculus - Terms
A selection of articles related to simply typed lambda calculus Terms.
http://www.experiencefestival.com/simply_typed_lambda_calculus_-_terms
Articles Archives Start page News Contact Community General Newsletter Contact information Site map Most recommended Search the site Archive Photo Archive Video Archive Articles Archive More ... Wisdom Archive Body Mind and Soul Faith and Belief God and Religion ... Yoga Positions Site map 2 Site map
Hi! Below are some links that have been popular among the visitors of Global Oneness.
Check them out!
Jonas
##### A Wisdom Archive on Simply typed lambda calculus - Terms
Simply typed lambda calculus - Terms A selection of articles related to Simply typed lambda calculus - Terms More material related to Simply Typed Lambda Calculus can be found here: Main Page
for

Simply Typed Lambda Calcu...
Index of Articles ...
Simply typed lambda calcu...
Simply typed lambda calculus, Simply typed lambda calculus - Important results, Simply typed lambda calculus - Terms, Simply typed lambda calculus - Types
##### ARTICLES RELATED TO Simply typed lambda calculus - Terms
Simply typed lambda calculus - Terms: Encyclopedia II - Simply typed lambda calculus - Terms To define the set of well typed lambda terms of a given type, we introduce typing contexts which are sequences of typing assumptions of the form x:ÃÂ where x is a variable. We introduce the judgment which means that t is a term of type ÃÂ in context ÃÂ which is given by the following typing rules: Examples of closed terms are: (I), (K), and (S). These are the typed lambda calculus represen ...
Simply typed lambda calculus Simply typed lambda calculus - Types Simply typed lambda calculus - Terms Simply typed lambda calculus - Important results Read more here:

 15. JSTOR Exact Bounds For Lengths Of Reductions In Typed \$\lambda 3 R. LOADER, Notes on simply typed lambda calculus, Technical Report ECSLFCS-98-381, Edin- burgh. 4 H. SCHWICHTENBERG, Complexity of normalization inhttp://links.jstor.org/sici?sici=0022-4812(200109)66:3<1277:EBFLOR>2.0.CO;2-5

16. Programming: Simply Easy! (An Implementation Of A Dependently Typed Lambda Calcu
I think it may come as a surprise to many people that it doesn t need to be much harder than implementing the simply typed lambda calculus.
 register submit help blog ... stats search remember me recover password login sort by hot new top old other communities Simply Easy! (An Implementation of a Dependently Typed Lambda Calculus) (people.cs.uu.nl) 30 points posted 2 months ago by sjf 9 comments info comments related details augustss ... augustss 3 points 2 months ago In my opinion, this is neither the simplest nor easiest way to make a small dependently typed language. permalink WouterSwierstra (6 children) [+] WouterSwierstra 2 points 2 months ago Care to expand? I'd certainly be interested in your thoughts. permalink parent augustss (5 children) [+] ... augustss 10 points 2 months ago A few things: I don't think deBruijn indicies makes things simpler in total. If I want to make something simple I just implement substitution with a little bit of alpha-conversion built in and equality with on-th-fly alpha conversion. It's very easy; no global name generators or anything like that. Using real variable names is, IMO, more natural and definitely more readable. I would not use a special types for values (and neutral terms). It just adds to the number of types and adds strange functions like quote. (I know it has advantages in that the Haskell type checker can help you more if you make the distinction. I wonder if phantom types/GADTs could be used to the same effect.) You really start to notice the overhead when adding more constructors to the term type that then need to be mirrored in the value type.

17. Re: Simple Question Regarding Simply Typed Lambda Calculus
simply typed lambda calculus? Why exactly do we a verb to state a sentence? Prev by Date Simple Question regarding simply typed lambda calculus
http://sci.tech-archive.net/Archive/sci.logic/2006-11/msg00060.html
##### Re: Simple Question regarding Simply Typed Lambda Calculus
• From Date : Thu, 2 Nov 2006 00:48:33 -0800
On Thu, 2 Nov 2006, Debajit Adhikary wrote:
Why exactly do we need to define a context (indicated using Gamma) in
Simply Typed Lambda Calculus?
Why exactly do we a verb to state a sentence?
What happens if we left out the Gamma?
What happens if we out the verb?

18. TAPL Exercises For Lecture 4 (2004-09-15)
Show that this coding does not work in the simply typed lambda calculus with Show that the simply typed lambdacalculus extended with fix (11-12) is NOT
http://www.diku.dk/undervisning/2004e/224/ex2004-09-22.html
##### TAPL exercises for Lecture 4 (2004-09-22)
Do at least 4 of the following 7 exercises.
• Consider the following coding of pairs in the untyped lambda-calculus:
rep[x] = x
rep[t t'] = rep[t] rep[t']
Do Exercise 11.8.2, but (only) for pairs instead of (full-blown) records. Consider TAPL, Fig. 9-1, extended as follows:
New syntactic forms:
New evaluation rules:
(E-INL) and (E-INR) as in Fig. 11-9.
New typing rules:
(T-INL) and (T-INR) as in Fig. 11-9.
The n-th Fibonacchi number fib(n) is defined by fib(0) = fib(1) = 1 fib(n) = fib(n-1) + fib(n-2) Consider the fixpoint operator Y Show that the simply typed lambda-calculus remains normalizing when extended with Booleans (3-1), products (11-5) and sums (11-9). [Hint: The extension with Booleans and products is given in TAPL, Solutions to selected exercises. Do the missing cases for sums.] Show that the simply typed lambda-calculus extended with fix (11-12) is NOT normalizing.
• The homework is due in writing by 9:15, Wednesday 29/9 , that is before start of next lecture. If you turn in your homework to Fritz in N203 by Monday, 27/9, 16:00, you can get your homework returned Wednesday, 29/9. Otherwise you will get it returned the following Wednesday, 6/10. (Solutions will be discussed at the beginning on the Wednesday, 29/9, lecture, in any case.) Fritz Henglein

19. Simply Typed Lambda Calculus
In the simply typed lambda calculus, we begin with a syntax for types. Since we have no constants in our set of lambda terms, we fix a single type constant
Next: Polymorphic typed calculi Up: Introducing types into the Previous: Introducing types into the Contents
##### Simply typed lambda calculus
In the simply typed lambda calculus, we begin with a syntax for types. Since we have no constants in our set of lambda terms, we fix a single type constant that represents an atomic type. The syntax of types is then given by the grammar
Thus, examples of types are . As we have seen in Haskell, the operator associates to the right. We now build up typed terms inductively in such a way that only well typed terms are generated. First, for each type , we fix a separate set of variables. Then, we define by mutual induction the set of lambda terms of each type as follows:
• For each , every variable of type is in If is a term in and is a term in then is a term in If is a term in and is a variable of type then is a term in
• Notice that every term we construct has a well defined type. Terms like that gave us some apparently contradictory behaviour earlier cannot be assigned a type (why?) and are thus not legal terms of this calculus. The rule for the simply typed lambda calculus is the usual one, with a check for type consistency:

20. Calculus
The simply typed lambda calculus A. syntax TYPED LANGUAGE CONCRETE SYNTAX t,s in Type-Expr e in Expr x in Identifier t = o t - t (t)
http://www.cs.iastate.edu/~leavens/ComS541Fall03/meeting-outlines/lambda-calculu
 inc - 4. convertability relation denoted =, cnv, or Y, then there is some Z such that X >* Z and Y >* Z (this property is called *confluence*) - - 2. If X has a normal form Y, there is a normal order reduction from X to Y. corollary: if want to find normal form, use normal order eval. - D. Normalization, comparison of simply typed and untyped calculus - NORMALIZATION def: a system is * weakly normalizing (or church-rosser, confluent): if only one normal form for a term * strong normalizing (terminating): if every term has a normal form -

21. HORPO - The Higher Order Recursive Path Ordering In Coq
simply typed lambda calculus is used as a meta language in higherorder rewriting and A Formalization of the simply typed lambda calculus in Coq.
http://www.win.tue.nl/~akoprows/coq-horpo/index.html
HORPO
(The Higher Order Recursive Path Ordering) About HORPO News Download Relevant publications ...
• About HORPO - what is it all about. News - stay informed! - you can download Coq sources of HORPO here or browse them online. Relevant publications - publications concerning HORPO.
Dershowitz' recursive path ordering (RPO) is one of the important methods for proving termination of term rewrite systems (TRSs). J.-P. Jouannaud and A. Rubio proposed its generalization for the higher-order case giving rise to HORPO: Higher-order recursive path ordering. This project's goal is the formalization of the HORPO ordering in the proof checker Coq
##### Motivation
This formalization is part of CoLoR : the Coq Library on Rewriting and Termination. Color's ultimate goal is to certify termination proofs produced by tools like AProVE Cime Matchbox TORPA ... TTT . For that purpose first the theory behind existing termination techniques (like RPO) has to be formalized.
##### Overview
The formalization of HORPO is complete (axiom-free) and fully constructive. The main result states that union of the HORPO ordering and the beta-reduction relation of the simply typed lambda calculus is well-founded. Simply typed lambda calculus is used as a meta language in higher-order rewriting and multisets are used for comparison of arguments is the HORPO ordering so they had to be formalized as well. The formalization contains around 25.000 lines of Coq scripts at the moment. It roughly consists of the following three parts (see

 22. Scientific Commons Finite Model Theory In The Simply Typed Lambda Finite Model Theory in the simply typed lambda calculus (1994). Gerd G. Hillebrand,; Paris C. Kanellakis,; Harry G. Mairson,; Pascal Van Hentenryckhttp://en.scientificcommons.org/85619

23. Roberto Di Cosmo's Abstracts
We show the usefulness of the lemmas by applying them to various systems, ranging from simply typed lambda calculus to higher order lambda calculi,
http://www.pps.jussieu.fr/~dicosmo/Publications/Abstracts.html
##### Abstracts
Here are the abstracts of most of the works you can find referenced in my publications page , where you will find the pointers to the online available documents.
##### Provable isomorphisms of types: from Lambda Calculus to Information Retrieval and Language Design.
This book (see here for a more detailed overview) is devoted to the study of the notion of type-isomorphisms in functional languages, both from a theoretical and a practical point of view. Based on my PhD dissertation, it has been extensively revised, updated and provided with a completely new introduction to the topic, that makes it accessible to a wide spectrum of readers. It tries hard to provide a complete reference and discussion of all research done in this area, from the definition of confluent rewriting systems for typed lambda calculi equipped with various extensionality rules, to the characterization of isomorphisms of types in different typed calculi, to the applications to extensions of ML-style type-inference algorithms and the design of library search tools based on types (you can test a sample implementation right now: english or french
##### Provable isomorphisms of types
A constructive characterization is given of the isomorphisms which must hold in all models of the typed lambda calculus with surjective pairing. By the close relation between closed Cartesian categories and models of these calculi, we also produce a characterization of those isomorphisms which hold in all CCC's. By the correspondence between these calculi and proofs in intuitionistic positive propositional logic, we thus provide a characterization of equivalent formulae of this logic, where the definition of equivalence of terms depends on having invertible'' proofs between the two terms. Rittri (1989), on types as search keys in program libraries, provides an interesting example of use of these characterizations.

24. CiNii - A Canonical Translation From Higher Order Logic To Typed Lambda Calculus
Keyword simply typed lambda calculus polymorphic typed lambda calculus Caluculus of Constructions kind formulaeas-types higher order intuitionistic many
http://ci.nii.ac.jp/naid/110002807366/en/
Top Page Browse Publications Citation Index CiNii+Citation Index ... Japanese Journal Title
##### Journal of Japanese Society for Artificial Intelligence
Vol.5, No.6(19901101) pp. 796-807 The Japanese Society for Artificial Intelligence ISSN:09128085 Bibliography
##### Fujita Ken-etsuTogashi AtsushiNoguchi Shoichi
Dept. of Artificial Intelligence, Kyushu Institute of Technology Research Institute of Electrical Communication, Tohoku University Research Center for Applied Information Sciences, Tohoku University Keyword simply typed lambda calculus polymorphic typed lambda calculus Caluculus of Constructions kind ... higher order intuitionistic many sorted predicate logic Abstract The relationship between higher order intuitionistic many sorted predicate logic (denoted by L) and the type systemÂ¦ÃPK2 (Coquand-Huet's Calculus of Constructions) is investigated using the formulae-as-types notion. As a necessary consequence, the type system Â¦ÃKF which is a restricted version ofÂ¦ÃPK2 is obtained to interpret just L. The Â¦ÃKF has made it possible to arrive at an inverse interpretation to L. The interpretation is more constructive than the existing one in the sense that it may also be applied to a proof figure to get a judgment constructively. The soundness and completeness results are given. In this sense, the whole logical system can be translated into the type system, and hence proofs in L are treated formally in Â¦ÃKF. Read/Search Full Text CiNii PDF Holdings

25. Fall 98, CSE 520: Lectures
The important properties of the Lambda Calculus and of the Curry system hold also for the simply typed lambda calculus and the Church system.
http://www.lix.polytechnique.fr/~catuscia/teaching/cg520/98Fall/lecture_notes_98
##### First Order Unification
There are various algoriths to find the most general unifier for a set of first order equations; for instance, the algorithm of Martelli-Montanari (see [ , Section 2]). Proposition The algorithm of Martelli-Montanari always terminates and it gives a most general unifier if the set of equations is solvable, failure otherwise. Corollary Given a set of first order equations E, it is decidable whether E is solvable or not, and, if it is solvable, then it has a most general unifier (which is unique modulo renaming).
##### Uses of unification in programming languages
• ML uses
• First order unification for type inference at compile time (transparent to the user)
• Pattern matching (a sort of one-way unification) for evaluating function calls
• Prolog uses first order unification for evaluating goals. For efficiency reasons the occur-check is usually not implemented.
• Lambda Prolog uses Higher Order Unification (unification of Higher-Order terms modulo alpha, beta and eta conversion) for evaluating goals. This is a conservative extension of FO unification, in the sense that if we give to lambda Prolog a FO equation, then we get back the FO most general unifier. Those who are interested can find the algorithm for HO unification in [G. Huet, A Unification Algorithm for Typed lambda-Calculus, Theoretical Computer Science
##### Properties of the type system of Curry
From the properties of FO unification, we have that:

26. Lemon
Functional language with inductive and coinductive types. Based on simplytyped lambda calculus augmented with sums, products, and mu and nu constructors for least (inductive) and greatest (coinductive) solutions to recursive type equations.
http://www.cis.ksu.edu/~bhoward/lemon.html
##### A Functional Language with Inductive and Coinductive Types
The functional language lemon is based on the simply-typed lambda calculus augmented with sums, products, and the mu and nu constructors for least ( inductive ) and greatest ( coinductive ) solutions to recursive type equations. The term constructors of the language strictly follow the introduction and elimination rules for the corresponding types; in particular, the elimination for mu is iteration and the introduction for nu is coiteration (also called generation ). It includes a small amount of polymorphism and type inference; lambda-bound variables do not need type annotations, but iteration and coiteration need to have their corresponding recursive types specified (this is a problem with the language rather than the implementation). For example, the following program generates the stream of Fibonacci numbers starting with 1,1: Using iteration we may define a function which picks off the first n elements of a stream and returns them as a list: We may combine these terms as follows (currently there is syntactic sugar for natural numbers but not for lists; formatting inserted by hand for clarity):

27. Simply-typed Lambda Calculus - The Twelf Project
The simplytyped lambda calculus is a common example of a simple typed programming language. This article discusses its encoding in Twelf.
http://twelf.plparty.org/wiki/Simply-typed_lambda_calculus
var skin = 'monobook';var stylepath = '/w/skins';
##### From The Twelf Project
Jump to: navigation search The simply-typed lambda calculus is a common example of a simple typed programming language. This article discusses its encoding in Twelf. If you're trying to learn Twelf from this example, you may wish to read the discussion starting in Representing the syntax of the STLC in the tutorial Proving metatheorems with Twelf . That introductory guide discusses this representation of the STLC and why it works in more detail. This page summarizes the judgements of the STLC and the corresponding LF code for reference, but does not explain them in detail.
##### Contents

28. A Normalization Proof A La Tait For Simply-typed Lambda-calculus
A normalization proof a la Tait for simplytyped lambda-calculus. This is a formalization of Berger s TLCA 93 paper, with complete proofs of the axioms and
http://coq.inria.fr/contribs/tait.html
##### A normalization proof a la Tait for simply-typed lambda-calculus
This is a formalization of Berger's TLCA'93 paper, with complete proofs of the axioms and an extraction of a normalization program close to N.B.E. Download (archive compatible with Coq V8.1) Authors:
• Pierre Letouzey (LMU, Munich) Helmut Schwichtenberg (LMU, Munich)
Date: Keywords: Normalization, Lambda-calculus, Extraction, Tait proof, N.B.E. The README file of the contribution: This page was automatically generated from this description file

29. [cs/0701022v1] Definable Functions In The Simply Typed Lambda-calculus
Abstract It is a common knowledge that the integer functions definable in simply typed lambdacalculus are exactly the extended polynomials.
http://arxiv.org/abs/cs.LO/0701022v1
##### arXiv.orgcs
Search or Article-id Help Advanced search All papers Titles Authors Abstracts Full text Help pages
Citations p revious n ... ext
##### Title: Definable functions in the simply typed lambda-calculus
Authors: Mateusz Zakrzewski (Submitted on 4 Jan 2007) Abstract:
We prove that the class of functions strictly definable in simply typed lambda-calculus is considerably larger than the extended polynomials. Namely, we define F as the class of strictly definable functions and G as a class that contains extended polynomials and two additional functions, or more precisely, two function schemas, and is closed under composition. We prove that G is a subset of F.
Comments: Submitted to TLCA 2007 Subjects: Logic in Computer Science (cs.LO) Cite as: arXiv:cs/0701022v1 [cs.LO]
##### Submission history
From: Mateusz Zakrzewski [ view email
Thu, 4 Jan 2007 17:50:01 GMT (7kb)
Which authors of this paper are endorsers?
Link back to: arXiv form interface contact

30. The Weak Normalization Of The Simply Typed {lambda}se-calculus -- Arbiser Et Al.
In this paper, we show the weak normalization (WN) of the simplytyped {lambda} se-calculus with open terms where abstractions are decorated with types,
http://jigpal.oxfordjournals.org/cgi/content/abstract/15/2/121
@import "/resource/css/hw.css"; @import "/resource/css/igpl.css"; Skip Navigation Oxford Journals
Logic Journal of IGPL Advance Access originally published online on May 15, 2007
Logic Journal of IGPL 2007 15(2):121-147; doi:10.1093/jigpal/jzm003
most recent
Alert me if a correction is posted Services Email this article to a friend Similar articles in this journal Alert me to new issues of the journal Add to My Personal Archive ... Request Permissions Google Scholar Articles by Arbiser, A. Articles by Rios, A. Search for Related Content
##### The Weak Normalization of the Simply Typed s e -calculus
Ariel Arbiser Fairouz Kamareddine School of Mathematical and Computer Sciences, Heriot-Watt University, Riccarton, Edinburgh EH14 4AS, Scotland. E-mail: Alejandro Rios
Abstract In this paper, we show the weak normalization (WN) of the simply-typed s e -calculus with open terms where abstractions are decorated with types, and metavariables, de Bruijn indices and updating

31. Lambda Calculus And Lambda Calculators
Predecessor and lists are not representable in simply typed lambdacalculus. The predecessor of a Church-encoded numeral, or, generally, the encoding of a
http://okmij.org/ftp/Computation/lambda-calc.html
previous next contents top
##### Negative numbers, subtraction and division in lambda-calculus
This article will demonstrate basic arithmetic operations comparison, addition, subtraction, multiplication, and division on non-negative and negative integer numbers. Both the integers and the operations on them are represented as terms in the pure untyped lambda-calculus. The only building blocks are identifiers, abstractions and applications. No constants or delta-rules are used. Reductions follow only the familiar beta-substitution and eta-rules. We also show two approaches of defining a predecessor of a Church numeral. Curiously, none of the arithmetic operations involve the Y combinator; even the division gets by without Y. Addition, multiplication, squaring, and exponentiation are easily expressed in lambda-calculus. We discuss two approaches to their "opposites" subtraction, division, finding of a square root and of a discrete logarithm. The "opposite" operations present quite a challenge. One approach, based on fixpoints, is more elegant but rather impractical. The "dual" approach, which relies on counting, leads to constructive and useful, albeit messy, terms.

32. CIS 705 -- Programming Languages -- Spring 2007
Reading Chapters 12 and 13 of TAPL; Normalization of the simply typed lambdacalculus. Session 39 Apr 25. Reading Chapters 12 and 13 of TAPL
http://people.cis.ksu.edu/~stough/705/index.html
Instructor Alley Stoughton Office Phone E-mail stough@cis.ksu.edu WWW Home Page www.cis.ksu.edu/~stough/ Course WWW Page www.cis.ksu.edu/~stough/705/ Lectures MWF 1:30-2:20 p.m. N127 Office Hours TU 1:30-2:20 p.m. N214
##### Class Sessions
In the following, TAPL stands for the book Types and Programming Languages , and DAWOC stands for the book Developing Applications With Objective Caml . The OCaml programs referred to below can also be found in the directory ~stough/705 /home/faculty/stough/705 ) on the CIS Linux system.
• Session 1: Jan 12
• Reading: Chapter 1 of TAPL Course Syllabus ( view print Tour of course WWW page TAPL Chapter 1: Introduction ( view print
Session 2: Jan 17
• Reading: Chapters 1 and 2 of TAPL TAPL Chapter 1: Introduction ( view print TAPL Chapter 2: Mathematical Preliminaries ( view print
Session 3: Jan 19
• Reading: Chapter 3 of TAPL TAPL Chapter 2: Mathematical Preliminaries ( view print TAPL Chapter 3: Untyped Arithmetic Expressions (A) ( view print
Session 4: Jan 22
• Reading: Chapter 3 of TAPL TAPL Chapter 3: Untyped Arithmetic Expressions (A) ( view print
Session 5: Jan 24
• Reading: Chapter 3 of TAPL TAPL Chapter 3: Untyped Arithmetic Expressions (A) ( view print
Session 6: Jan 26
• Reading: Chapter 3 of TAPL TAPL Chapter 3: Untyped Arithmetic Expressions (A) ( view print TAPL Chapter 3: Untyped Arithmetic Expressions (B) ( view print
Session 7: Jan 29
• Reading: Chapter 3 of TAPL TAPL Chapter 3: Untyped Arithmetic Expressions (B) ( view print
Session 8: Feb 2

33. Atlas: Extensional Isomorphisms Of Inductive Types In Simply-Typed Lambda-Calcul
We study isomorphisms of types in the system of simplytyped lambda-calculus with inductive types and recursion operators. It is shown that in some cases
http://atlas-conferences.com/c/a/j/y/04.htm
 Atlas home Conferences Abstracts about Atlas Second St.Petersburg Days of Logic and Computability August 24-26, 2003 Petersburg Department of Steklov Institute of Mathematics St. Petersburg, Russia Organizers Sergei ADIAN (Russia), Sergei ARTEMOV (Russia/USA), Nikolai KOSSOVSKI (Russia), Maurice MARGENSTERN (France), Grigori MINTS (USA), Yuri MATIYASEVICH (Russia), the chairman, Nikolai NAGORNY (Russia), Vladimir OREVKOV (Russia), Anatol SLISSENKO (France) View Abstracts Conference Homepage Extensional Isomorphisms of Inductive Types in Simply-Typed Lambda-Calculus by David Chemouil IRIT, University Paul Sabatier, Toulouse Coauthors: Sergei Soloviev (IRIT, University Paul Sabatier, Toulouse) We study isomorphisms of types in the system of simply-typed lambda-calÂ­cuÂ­lus with inductive types and recursion operators. It is shown that in some cases (multiproducts, copies of types), it is possible to add new reductions in such a way that strong normalisation and confluence of the calculus are preserved, and the isomorphisms may be regarded as intensional w.r.t. a stronger equality relation. Date received: March 7, 2003

 34. Background On Type Systems A Type Error Occurs When We Attempt To Write a typechecker for the simply-typed lambda calculus with unit, pairs, and sums. Use the following definitions datatype Type = Int_t Arrow_t ofhttp://www.cs.cornell.edu/courses/cs411/2003fa/lecture_16_oct.txt

35. Typed Lambda Calculus And Applications
Categorical completeness results for the simplytyped lambda-calculus. by Alex K. Simpson. Comparing lambda-calculus translations in Sharing Graphs
http://wotan.liu.edu/docis/dbl/tlcatl/index.html
 The Digital Librarian's Digital Library search D O CISÃÂ  Do cumentsÃÂ inÃÂ  C omputing and I nformationÃÂ  S cience Home Journals and Conference Proceedings Typed Lambda Calculus and Applications Untyped Algorithmic Equality for Martin-LÂ¶f's Logical Framework with Surjective Pairs by:ÃÂ  Andreas Abel, Thierry Coquand A Lambda Calculus for Quantum Computation with Classical Control by:ÃÂ  Peter Selinger, Benoit Valiron Elementary Affine Logic and the Call-by-Value Lambda Calculus by:ÃÂ  Paolo Coppola, Ugo Dal Lago, Simona Ronchi Della Rocca Binding Signatures for Generic Contexts by:ÃÂ  John Power, Miki Tanaka A Feasible Algorithm for Typing in Elementary Affine Logic by:ÃÂ  Patrick Baillot, Kazushige Terui Semantic Cut Elimination in the Intuitionistic Sequent Calculus by:ÃÂ  Olivier Hermant Galois Embedding from Polymorphic Types into Existential Types by:ÃÂ  Ken-etsu Fujita Arithmetical Proofs of Strong Normalization Results for the Symmetric lambda-ÃÂµ-Calculus by:ÃÂ  RenÂ© David, Karim Nour Filters on CoInductive Streams, an Application to Eratosthenes' Sieve by:ÃÂ  Yves Bertot Completeness Theorems and lambda-Calculus by:ÃÂ  Thierry Coquand L3: A Linear Language with Locations by:ÃÂ  Greg Morrisett, Amal J. Ahmed, Matthew Fluet

 36. Citebase - Definable Functions In The Simply Typed Lambda-calculus Fortune, S., Leivant, D., O Donnell, M. The expressiveness of simple and second order type structures. Journal of the ACM, 30151185, 1983.http://www.citebase.org/abstract?identifier=oai:arXiv.org:cs/0701022&action=cite

37. HOR 2007 Abstracts
First I describe a simply typed lambdacalculus with inductive and coinductive types and guarded (co)recursion in the style of N. P. Mendler.
http://www.irit.fr/~Ralph.Matthes/HOR/HOR2007abstracts.html
 HOR 4th International Workshop on Higher-Order Rewriting Monday June 25, 2007 Paris, France ABSTRACTS : On the formalization of logical relation arguments in Twelf Tait's method (a.k.a. proof by logical relations) is a powerful proof technique frequently used for showing foundational properties of languages based on typed lambda-calculi. Historically, these proofs have been difficult to formalize in Twelf, in part because logical relations are difficult to define judgementally. In this talk I discuss how we did it, and what lessons we have learned about the relationship between logical frameworks, the consistency of logical systems, well-founded orderings, and proof theory. This is joint work with Jeffrey Sarnat. Tarmo Uustalu : Circular proofs = Mendler in sequent form I present an interesting application of higher-order typed equational reasoning to structural proof theory. First I describe a simply typed lambda-calculus with inductive and coinductive types and guarded (co)recursion in the style of N. P. Mendler. This is a higher-order natural deduction system. Guardedness is expressed with type polymorphism. Then I show that remoulding this system as a higher-order sequent calculus yields a reconstruction with a solid foundation of Cockett and Santocanale's calculus of circular proofs (cf. Dam and Sprenger, Brotherston and Simpson). Andreas Abel : Syntactical strong normalization for intersection types with term rewriting rules We investigate the intersection type system of Coquand and Spiwack with rewrite rules and natural numbers and give an elementary proof of strong normalization which can be formalized in a weak metatheory.

38. Definable Functions In The Simply Typed Lambda-calculus
It is a common knowledge that the integer functions definable in simply typed lambdacalculus are exactly the extended polynomials.
Sign on
##### Smithsonian/NASA ADSarXiv e-prints Abstract Service
Find Similar Abstracts (with default settings below
arXiv e-print (arXiv:cs/0701022)
Translate Abstract
Title:
Definable functions in the simply typed lambda-calculus Authors:
Publication:

eprint arXiv:cs/0701022 Publication Date:
Origin:

ARXIV Keywords:
Computer Science - Logic in Computer Science Comment:
Submitted to TLCA 2007 Bibliographic Code:
##### Abstract
Bibtex entry for this abstract Preferred format for this abstract (see Preferences
##### Find Similar Abstracts:
Use: Authors Title Keywords (in text query field) Abstract Text Return: Query Results Return items starting with number Query Form Database: Astronomy Physics arXiv e-prints
ADS Sitemap Query Form Basic Search ... FAQ

39. Brian Howard's Papers
The first language discussed is a variant of Scott and Plotkin s PCF, which adds to the simplytyped lambda calculus products, fixed points of functions,
http://www.csc.depauw.edu/~bhoward/papers/
##### Available Papers
• Operational and Axiomatic Semantics of PCF (LISP and Functional Programming, 1990, with John C. Mitchell) Fixed Points and Extensionality in Typed Functional Programming Languages (Stanford Thesis, 1992) Inductive, Projective, and Retractive Types (UPenn Tech Report, 1993) Another Iteration on Darlington's "A Synthesis of Several Sorting Algorithms" (KSU Tech Report, 1994) Fixpoint Computations and Coiteration (KSU Tech Report, 1995) Inductive, Coinductive, and Pointed Types (International Conference on Functional Programming, 1996) Labeling Techniques and Typed Fixed-Point Operators (Higher Order Operational Techniques in Semantics, 1998, with John C. Mitchell and My Hoang) A Tool for the Automatic Adaptation of Software Components Based on Semantic Specifications (Algebraic Methodology and Software Technology, 2002, with Christian Haack, Alley Stoughton, and Joe Wells) Design of a Simple Functional Programming Language and Environment for CS2 (Consortium for Computing Sciences in Colleges-Midwest, 2006) SCALES: Learning Multimedia in a Mixed-Paradigm Language (Midstates Conference for Undergraduate Research in Computer Science and Mathematics, 2007, with Cory D. Boatright)

40. Peter Selinger Papers
Abstract In this paper, we develop a functional programming language for quantum computers, by extending the simplytyped lambda calculus with quantum
http://www.mscs.dal.ca/~selinger/papers.html
Papers
This is a list of Peter Selinger 's papers, along with abstracts and hyperlinks. See also:
##### Proceedings of the Eleventh International Conference on Foundations of Software Science and Computation Structures (FOSSACS 2008), Budapest

41. Harry Mairson
Expressibility and typed lambda calculus I recently developed a new proof the normal forms of two simply typed lambda terms is not Kalmarelementary.
http://cs-people.bu.edu/mairson/
##### Harry Mairson
Ph.D., Computer Science, Stanford University, 1984
Visiting Professor of Computer Science
mairson@cs.bu.edu
283 MCS / (617) 353-8923
##### Research Interests Optimal evaluation Game semantics and proof structures Expressibility and typed lambda calculus ... Other Research Interests My research examines the interaction between mathematical logic and computation theory, with application to the design and analysis of functional programming languages, type systems, and database query languages. A primary current research interest is optimal evaluation in lambda calculus and its computational complexity. I also do fundamental research in algorithmics and algorithm analysis. Optimal evaluation: An evaluator for lambda calculus (or more broadly speaking, a functional programming language) is said to be correct and optimal if it returns a normal form whenever there is one (i.e., it never diverges by choosing to evaluate the wrong redex), and never does inessential work (i.e., copying redexes). Recently, several researchers, including Lamping, Gonthier, Abadi, Levy, and Asperti, have constructed optimal evaluators. But are they efficient? I have examined the computational complexity of this problem via the algorithmic analysis of these proposed evaluators. In addition, this work has addressed what reasonable

 42. Rotten Cotton Â» Blog Archive Â» Bootstrapping From The Pure Lambda Calculus Y doesnÂt type in the *simply* typed lambda calculus. There are type systems that type it properly. Cotton Says January 25th, 2007 at 411 amhttp://onebadseed.com/blog/?p=34

43. Date Tue, 5 Jul 1994 085606 +0500 (GMT+400) From Categories
The results concern two categorical notions of completeness for betaeta conversion relative to the interpretation of the simply-typed lambda-calculus in
http://www.mta.ca/~cat-dist/catlist/1999/completeness-lambda-calc
 Date: Tue, 5 Jul 1994 08:56:06 +0500 (GMT+4:00) From: categories Subject: Categorical completeness results for the simply-typed lambda calculus.o Date: Mon, 04 Jul 94 18:35:50 +0100 From: Alex Simpson Subject: Re: Categorical completeness results for the simply-typed lambda calculus. Date: Wed, 6 Jul 94 14:25:55 EDT From: Djordje Cubric I would like to make a point of an empty set'' and say that Friedman's completeness theorem for typed lambda calculus (with appropriate changes) implies the completeness result for free cartesian closed categories (as mentioned in a recent posting of Alex Simpson) provided that one proves first that in a free ccc all objects have a global support. One way to do that is to prove the confluence for the appropriate system of reductions. Some of the recent papers were dealing with these reductions. One can see that the completeness holds even when the free ccc has also free arrows among freely generated types. Djordje Cubric

44. Publications
In the simplytyped lambda calculus, logical relations are the standard choice for simulation relations, but they suffer from certain shortcomings;
http://www.kurims.kyoto-u.ac.jp/~sinya/paper/
##### Publications
• Shin-ya Katsumata and Susumu Nishimura. Algebraic Fusion of Functions with an Accumulating Parameter and Its Improvement . In Proc. ICFP 2006. ( author's version in PDF ACM DL
Shin-ya Katsumata. A Semantic Formulation of TT-lifting and Logical Predicates for Computational Metalanguage . In Proc. CSL 2005. LNCS PDF A semantic formulation of Lindley and Stark's TT-lifting is given. We first illustrate our semantic formulation of the TT-lifting in Sets with several examples, and apply it to the logical predicates for Moggi's computational metalanguage. We then abstract the semantic TT-lifting as the lifting of strong monads across bifibrations with lifted symmetric monoidal closed structures.
(This work further develops the example I considered in chapter 4 of my PhD thesis . The trip to the conference was partially supported by Saneyoshi Shogakukai Shin-ya Katsumata. A Generalisation of Prelogical Predicates to Simply Typed Formal Systems . In Proc. ICALP 2004. LNCS PDF ; this is a revised version from the ICALP hand out. see

45. 3.4.4 [Sidetrack] Simply Typed Lambda-Calculus
3.4.4 Sidetrack simply typed lambdacalculus. In this section we discuss two topics that are important in connection with -calculus, but that have been
http://www.coli.uni-saarland.de/projects/milca/courses/comsem/html/node59.html
- Up -
##### 3.4.4 [Sidetrack] Simply Typed Lambda-Calculus
In this section we discuss two topics that are important in connection with -calculus, but that have been ommited so far: Types and the semantics of -expressions in terms of functions. The perspective we've been taking on -calculus so far has been a very technical one. We 've been viewing it simply as a tool for controlling substitutions, without caring much what single -expressions actually mean. If you've heard about -Calculus before in other semantics textbooks or lectures, you will probably feel that we have left out a discussion of at least two points:
• Types: The version of -calculus most commonly used in linguistics is simply typed -calculus . In this calculus, expressions get assigned types that regulate function application. Functions: -expressions can be given an interpretation in terms of functions over a system of complex domains. (In fact -calculus was originally designed to investigate function definition, function application and recursion.)
• As regards the first point: The version of -calculus we're going to use is untyped, and we'll argue below that we don't have to interpret any

46. TLCA 1995
Andrea Asperti, Cosimo Laneve Comparing lambdacalculus translations in Sharing Categorical completeness results for the simply-typed lambda-calculus.
http://www.informatik.uni-trier.de/~ley/db/conf/tlca/tlca95.html
##### TLCA 1995: Edinburgh, UK
Mariangiola Dezani-Ciancaglini Gordon D. Plotkin (Eds.): Typed Lambda Calculi and Applications, Second International Conference on Typed Lambda Calculi and Applications, TLCA '95, Edinburgh, UK, April 10-12, 1995, Proceedings. Lecture Notes in Computer Science 902 Springer 1995, ISBN 3-540-59048-X BibTeX DBLP

47. Examples.CPS
A certified CPS transformation for a simplytyped lambda calculus Call lambda Tamer generic programming to build some support code.
http://ltamer.sourceforge.net/coq/examples.CPS.html
##### Library examples.CPS
A certified CPS transformation for a simply-typed lambda calculus Require Import List. Require Import LambdaTamer.LambdaTamer. Require Import LambdaTamer.Tactics. Set Implicit Arguments.
##### Syntax and typing rules (combined via dependent types)
Types Inductive sty : Set := SBool : sty Terms Inductive SVar : forall G t, Var G t SConst : forall G, bool SLam : forall G dom ran, sterm (dom :: G) ran SApp : forall G dom ran, sterm G (SArrow dom ran) SPair : forall G t1 t2, sterm G t1 SFst : forall G t1 t2, sterm G (SProd t1 t2) SSnd : forall G t1 t2, sterm G (SProd t1 t2)
##### Dynamic semantics
Denotation function for types Fixpoint styDenote (t : sty) : Set := match t with end. Denotation function for terms Fixpoint end.
##### Syntax and typing rules
Types Inductive cty : Set := CBool : cty Primitive expressions Inductive CVar : forall G t, Var G t CConst : forall G, bool CLam : forall G t, cexp (t :: G) tt CPair : forall G t1 t2

48. The Weak Normalization Of The Simply Typed Lambda-se Calculus
The Weak Normalization of the simply typed lambdase calculus.
http://publicaciones.dc.uba.ar/Publications/2006/AKR06/
##### The Weak Normalization of the Simply Typed Lambda-se Calculus
Ariel Arbiser, F. Kamareddine, Alejandro RÃ­os Logic Journal of the Interest Group of Pure and Applied Logic - 2006
##### Other publications in the database
E-mail any comment Basilic 1.5.13

49. A Certified Type-Preserving Compiler From Lambda Calculus To Assembly Language
I present a certified compiler from simplytyped lambda calculus to assembly language. The compiler is certified in the sense that it comes with a
##### A Certified Type-Preserving Compiler from Lambda Calculus to Assembly Language
Adam Chlipala . A Certified Type-Preserving Compiler from Lambda Calculus to Assembly Language. Proceedings of ACM SIGPLAN 2007 Conference on Programming Language Design and Implementation (PLDI'07) . June 2007.
I present a certified compiler from simply-typed lambda calculus to assembly language. The compiler is certified in the sense that it comes with a machine-checked proof of semantics preservation, performed with the Coq proof assistant. The compiler and the terms of its several intermediate languages are given dependent types that guarantee that only well-typed programs are representable. Thus, type preservation for each compiler pass follows without any significant "proofs" of the usual kind. Semantics preservation is proved based on denotational semantics assigned to the intermediate languages. I demonstrate how working with a type-preserving compiler enables type-directed proof search to discharge automatically large parts of the proof obligations. Software/proof source code and documentation Slides are available from my PLDI talk in OpenOffice and PDF formats.

 50. Libra: Weak Normalization For The Simply - Typed Lambda - Calculus In Twelf Abstract We formalize in the logical framework ATS/LF a proof based on Tait s method that establishes the simplytyped lambda-calculus being stronglyhttp://libra.msra.cn/papercited.aspx?id=1968278

51. Good Math Has Moved To
But it did end up with some problems, and to get around that, a concept of types was introduced, leading to the simple typed lambda calculus,
http://goodmath.blogspot.com/2006/05/types-in-lambda-calculus.html
ScienceBlogs : Types in Lambda Calculus @import url("http://www.blogger.com/css/blog_controls.css"); @import url("http://www.blogger.com/dyn-css/authorization.css?targetBlogID=23588438"); var BL_backlinkURL = "http://www.blogger.com/dyn-js/backlink_count.js";var BL_blogId = "23588438";
##### Types in Lambda Calculus
Now that we've got intuitionistic logic under our belts, we're ready to get back to lambda calculus: we've got the logical tools we need to define the model. Of course, nothing is ever quite that simple, is it?
What we've talked about so far is the simple untyped lambda calculus. That's how LC started; it's the first version that Church invented. But it did end up with some problems, and to get around that, a concept of types was introduced, leading to the simple typed lambda calculus, and on from there to a world of variants - SystemT, SystemF, the Lambda Cube (not related to the time cube :-)), and so one. And eventually, people realized that the untyped lambda calculus was really just a simple pathologically simple case of a typed lambda calculus - it's a typed LC with only one type.
The semantics of lambda calculus are easiest to talk about in a typed version. For now, I'll talk about the simplest typed LC, known as the

52. Harry Mairson
Database query languages embedded in the typed lambda calculus (with G. A simple proof of a theorem of Statman Theoretical Computer Science 103 (1992),
http://www.cs.brandeis.edu/~mairson/
##### Harry Mairson
Ph.D., Computer Science, Stanford University, 1984
mairson at cs dot brandeis dot edu
257 Volen / (781) 736-2724
##### Research Interests Optimal evaluation Game semantics and proof structures Expressibility and typed lambda calculus ... Other Slides from my invited talk at ICFP 2003, From Hilbert space to Dilbert space: context semantics made simple. (Comments welcome. Sorry this is a big file.) Research Interests My research examines the interaction between mathematical logic and computation theory, with application to the design and analysis of functional programming languages, type systems, and database query languages. A primary current research interest is optimal evaluation in lambda calculus and its computational complexity. I also do fundamental research in algorithmics and algorithm analysis. Optimal evaluation: An evaluator for lambda calculus (or more broadly speaking, a functional programming language) is said to be correct and optimal if it returns a normal form whenever there is one (i.e., it never diverges by choosing to evaluate the wrong redex), and never does inessential work (i.e., copying redexes). Recently, several researchers, including Lamping, Gonthier, Abadi, Levy, and Asperti, have constructed optimal evaluators. But are they efficient? I have examined the computational complexity of this problem via the algorithmic analysis of these proposed evaluators. In addition, this work has addressed what reasonable

 Page 1     1-60 of 60    1