Geometry.net Online Store

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 From Wikipedia, the free encyclopedia 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 Contents Types Terms Important results References ... 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/

People Events Research 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: PDF file Gzipped PDF file PostScript file Gzipped PostScript file ... Next Unless explicitly stated otherwise all material Comments and corrections to: LFCS Webmaster Last modified: Friday 5 May 2006

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 Shin-Cheng Mu Home ... 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 User login Username: Password: Create new account Request new password Navigation recent posts 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

Masterclass Typed Lambda Calculus 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/

Ecole polytechnique f©d©rale de Lausanne Laboratoire des m©thodes de programmation Foundations of Software 2007-2008 fran§ais english EPFL LAMP Teaching Foundations of Software Exercise 3 Summary Assignment Implementation Hints Useful links Scala API Scala reference At a glance Deadline: November 2 nd Submission: Sygeco Code: project.zip 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 [1] MIT Scheme Reference Manual, MIT. [2] Abelson, H. and Sussman, G. J., Structure and Interpretation of Computer Programs, The MIT Press, 1985. Zentralblatt MATH: [3] Curien, P-L., An abstract framework for environment machines, Theoretical Computer Science, 82 (1991), 389-402. Mathematical Reviews (MathSciNet): Zentralblatt MATH: [4] Curien, P-L., Categorical combinators, Information and Control, 69 (1986), 188-254. Mathematical Reviews (MathSciNet): Zentralblatt MATH: [5] 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

The Lambda-calculus, Combinatory Logic, and Type Systems 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 Simply typed lambda calculus - Terms 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 ... See also: 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 in http://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. http://programming.reddit.com/info/5ytek/comments/

register submit help blog ... stats search remember me recover password login sort by hot new top old other communities reddit.com science politics business ... 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? References Simple Question regarding Simply Typed Lambda Calculus From: Debajit Adhikary Prev by Date: Simple Question regarding Simply Typed Lambda Calculus Next by Date: Re: incompleteness and inconsistency Previous by thread: Simple Question regarding Simply Typed Lambda Calculus Next by thread: Re: Simple Question regarding Simply Typed Lambda Calculus Index(es): Date Thread We are proud to have Web Hosting and Rack Housing from 9 Net Avenue Deutschland. Windows Science Usenet Archive ... sci.logic

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 http://www.cmi.ac.in/~madhavan/courses/pl2006/lecturenotes/lecture-notes/node109

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. About 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 Hentenryck http://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 A Canonical Translation from Higher Order Logic to Typed Lambda Calculus Fujita Ken-etsu Togashi Atsushi Noguchi 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

Fall 98, CSE 520: Lecture 10 (Sep 29) 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

Lemon 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'; Simply-typed lambda calculus 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 What is illustrated by this example? Encoding of syntax Encoding of judgments Static semantics ... edit What is illustrated by this example? There are simpler examples of LF representations (see, e.g., the natural numbers ). However, the STLC is a good first example of a representation that uses higher-order abstract syntax and higher-order judgments . These two representation techniques drastically simplify the process of representing and proving theorems about many programming languages and logics. The idea is that the binding structure of LF is used to represent the binding structure of the object language. At the level of syntax, this gives alpha-equivalence and capture-avoiding substitution "for free" from the representation. At the level of judgements, this gives the properties of a

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.org cs Search or Article-id Help Advanced search All papers Titles Authors Abstracts Full text Help pages Full-text links: Download: PostScript PDF Other formats Citations CiteBase p revious n ... ext Computer Science > Logic in Computer Science 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 Contact Us My Basket ... Volume 15, Number 2 Pp. 121-147 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 This Article Full Text Full Text (PDF) All Versions of this Article: most recent Alert me when this article is cited 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 Lambda Calculus and Lambda Calculators Negative numbers, subtraction and division in lambda-calculus Basic Lambda Calculus terms Numerals and lists in lambda-calculus: P-numerals The bluff combinator ... Predecessor and lists are not representable in simply typed lambda-calculus Lambda-calculators In Haskell In Scheme As a CPS R5RS Scheme macro As a short, direct-style R5RS Scheme macro 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 Resources Course Syllabus ( view print E-mail Messages OCaml Resources ... (DAWOC) Homepage 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 of http://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. http://adsabs.harvard.edu/abs/2007cs........1022Z

Sign on Smithsonian/NASA ADS arXiv e-prints Abstract Service Find Similar Abstracts (with default settings below arXiv e-print (arXiv:cs/0701022) Also-Read Articles Reads History 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 Smithsonian/NASA ADS Homepage 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) abstract PDF Fixed Points and Extensionality in Typed Functional Programming Languages (Stanford Thesis, 1992) abstract PDF Inductive, Projective, and Retractive Types (UPenn Tech Report, 1993) abstract PDF Another Iteration on Darlington's "A Synthesis of Several Sorting Algorithms" (KSU Tech Report, 1994) abstract PDF Fixpoint Computations and Coiteration (KSU Tech Report, 1995) abstract PDF Inductive, Coinductive, and Pointed Types (International Conference on Functional Programming, 1996) abstract PDF Labeling Techniques and Typed Fixed-Point Operators (Higher Order Operational Techniques in Semantics, 1998, with John C. Mitchell and My Hoang) abstract PDF 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) abstract PDF Design of a Simple Functional Programming Language and Environment for CS2 (Consortium for Computing Sciences in Colleges-Midwest, 2006) abstract PDF slides 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. Linear-non-linear model for a computational call-by-value lambda calculus (with B. Valiron Idempotents in dagger categories On a fully abstract model for a quantum linear functional language (with B. Valiron Tree checking for sparse complexes (with M. Caboara and S. Faridi Simplicial cycles and the computation of simplicial trees (with M. Caboara and S. Faridi A lambda calculus for quantum computation with classical control (with B. Valiron Dagger compact closed categories and completely positive maps Towards a semantics for higher-order quantum computation A brief survey of quantum programming languages ... has nonempty products See also: Proceedings of QPL 2006 (editor). Proceedings of QPL 2005 (editor). Proceedings of QPL 2004 (editor). Proceedings of CTCS 2002 (editor, with R. Blute). My compiler for the core join calculus My finite lambda model applet My compiler for the lambda-mu-nu calculus A linear-non-linear model for a computational call-by-value lambda calculus 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 am http://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 and Talks 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 Andrea Asperti Cosimo Laneve : Comparing Lambda-calculus translations in Sharing Graphs. 1-15 BibTeX Gilles Barthe : Extensions of Pure Type Systems. 16-31 BibTeX Roberto Bellucci Pierre-Louis Curien : A Model for Formal Parametric Polymorphism: A PER Interpretation for System R. 32-46 BibTeX Stefano Berardi Marc Bezem Thierry Coquand : A realization of the negative interpretation of the Axiom of Choice. 47-62 BibTeX Stefano Berardi Luca Boerio : Using Subtyping in Program Optimization. 63-77 BibTeX Gavin M. Bierman : What is a Categorical Model of Intuitionistic Linear Logic? 78-93 BibTeX Daniel Briaud : An explicit Eta rewrite rule. 94-108 BibTeX Yann Coscoy Gilles Kahn : Extracting Text from Proofs. 109-123 BibTeX Amy P. Felty

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. The source language: simply-typed lambda calculus 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. Target language: linearized STLC 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 BibTex references 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 http://www.cs.berkeley.edu/~adamc/papers/CtpcPLDI07/

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 strongly http://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"; Good Math has moved to ScienceBlogs Tuesday, May 30, 2006 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