Geometry.net Online Store

Geometry.Net - the online learning center
Home  - Lambda_Calculus - Lambda Calculus
  
Images 
Newsgroups
Page 1     1-95 of 95    1 

1. Lambda Calculus - Wikipedia, The Free Encyclopedia
In mathematical logic and computer science, lambda calculus, also calculus, is a formal system designed to investigate function definition,
http://en.wikipedia.org/wiki/Lambda_calculus
var wgNotice = ""; var wgNoticeLocal = ""; var wgNoticeLang = "en"; var wgNoticeProject = "wikipedia";
Lambda calculus
From Wikipedia, the free encyclopedia
Jump to: navigation search This article needs additional citations for verification
Please help improve this article by adding reliable references . Unsourced material may be challenged and removed. (October 2007) This article or section includes a list of references or external links , but its sources remain unclear because it lacks in-text citations
You can improve this article by introducing more precise citations. It has been suggested that Church encoding be merged into this article or section. ( Discuss In mathematical logic and computer science lambda calculus , also λ-calculus , is a formal system designed to investigate function definition, function application and recursion . It was introduced by Alonzo Church and Stephen Cole Kleene in the as part of a larger effort to base the foundation of mathematics upon functions rather than sets (in the hopes of avoiding obstacles like Russell's Paradox ). The

2. Lambda Calculus
An online introduction to the lambda calculus by Lloyd Allison, complete with a web form that will evaluate lambda expressions.
http://www.csse.monash.edu.au/~lloyd/tildeFP/Lambda/
var REMOTE_HOST="12.68.1243.static.theplanet.com", REMOTE_ADDR="67.18.104.18";
Lambda Calculus (interpreters)
LA home
FP

Lambda
Syntax

Introduction

Also see:
Prolog

Semantics

There are lazy and strict versions of the toy lambda-calculus interpreter. They both share the same input syntax and can be used on the same example lambda-calculus programs, although some programs will not work (i.e. will loop) when using the strict interpreter of course. Lazy Interpreter Strict Interpreter main programs Lazy.p Strict.p declarations define values lazy.type.P interpreters proper lazy.exec.P strict.exec.P output lazy.show.P
(evaluation is print driven) strict.show.P expressions lazy.eval.p (by-need evaluation) strict.eval.P (strict evaluation) apply functions lazy.apply.P strict.apply.P process declarations lazy.D.P strict.D.P binary operators lazy.O.P unary operators lazy.U.P strict.U.P manipulate environments lazy.env.P strict.env.P form basic values lazy.mkval.P

3. Lambda Calculus Introduction
lambda calculus provides the basis for Functional Programming languages.
http://www.csse.monash.edu.au/~lloyd/tildeFP/Lambda/Ch/
var REMOTE_HOST="12.68.1243.static.theplanet.com", REMOTE_ADDR="67.18.104.18";
Lambda Calculus
LA home
FP

Lambda
(code)
Syntax

Introduction

Also see:
PFL

Prolog intro

Semantics

  • Introduction ...
  • A Functional Programming Language
  • Programming Techniques: The Parser ...
  • Appendix - Misc' Routines
  • Lambda Calculus Example Programs
    The toy Lambda Calculus interpreter can be run through the wwweb. You should read at least the sections down to and including Programming Techniques first. There are very tight limits set on the size and running time of programs that can be run in this way. window on the wide world: The Darwin Awards 4: Intelligent Design Linux free op. sys. OpenOffice free office suite, ver 2.2+ The GIMP ~ free photoshop Firefox web browser list cons nil the [ ] list null predicate hd head (1st) tl tail (rest) L. Allison http://www.allisons.org/ll/ or as otherwise indicated Faculty of Information Technology (Clayton), Monash University, Australia 3800 (6/'05 was School of Computer Science and Software Engineering
  • 4. An Introduction To Lambda Calculus And Scheme
    The Lambdacalculus is a universal model of computation, that is, any computation that can be expressed in a Turing machine can also be expressed in the
    http://www.jetcafe.org/jim/lambda.html
    $Id: lambda.html,v 1.2 2001/02/01 01:43:43 jim Exp jim $
    An Introduction to Lambda Calculus and Scheme
    Jim Larson
    This talk was given at the JPL Section 312 Programming Lunchtime Seminar.
    Functions and Lambda Notation
    A function accepts input and produces an output. Suppose we have a "chocolate-covering" function that produces the following outputs for the corresponding inputs: peanuts -> chocolate-covered peanuts rasins -> chocolate-covered rasins ants -> chocolate-covered ants We can use Lambda-calculus to describe such a function: Lx.chocolate-covered x This is called a lambda-expression. (Here the "L" is supposed to be a lowercase Greek "lambda" character). If we want to apply the function to an argument, we use the following syntax: (Lx.chocolate-covered x)peanuts -> chocolate-covered peanuts Functions can also be the result of applying a lambda-expression, as with this "covering function maker": Ly.Lx.y-covered x We can use this to create a caramel-covering function: (Ly.Lx.y-covered x)caramel -> Lx.caramel-covered x (Lx.caramel-covered x)peanuts -> caramel-covered peanuts Functions can also be the inputs to other functions, as with this "apply-to-ants" function:

    5. Page Of Yves Lafont
    University of Marseille II Linear logic, lambda calculus, proof theory, term rewriting. Lafont invented the theory of interaction nets, an elegant theory of graph rewriting.
    http://iml.univ-mrs.fr/~lafont/welcome.html
    photo by M. Arovas Yves LAFONT
    professor at Aix-Marseille 2
    research at
    teaching at
    organizer of Logique et interactions
    address:
    office: - phone: - fax: - e-mail: lafont@iml.univ-mrs.fr
    Discipline
    mathematics Specialities logic algebra theoretical computer science Papers
    Recent papers: A folk model structure on omega-cat (with and Krzysztof Worytkiewicz Polygraphic resolutions and homology of monoids pdf ] (with Algebra and geometry of rewriting pdf ] (published in Applied Categorical Structures
    Other documents: The word problem pdf Homotopy of computation: The Minneapolis Program pdf ] - see also: The folk model structure for omega-categories pdf ] (by Krzysztof Worytkiewicz
    PhD students: Anne Massol Arnaud Fleury Virgile Mogbil Tom Krantz Sylvain Lippi Pierre Rannou (since 2007) Recent collaborators: Albert Burroni Patrick Dehornoy Yves Guiraud Krzysztof Worytkiewicz Research projects: ANR GDR Meetings: CIRM , 31 March - 4 April 2008) Teaching - Scientific popularization - Various links: see the french version of my home page

    6. Lambda Calculus
    That’s almost a good definition, however, due to the extreme thriftiness of lcalculus, we must impose an even more draconian restriction every LISP lambda
    http://www.mactech.com/articles/mactech/Vol.07/07.05/LambdaCalculus/
    MacTech Network: MacForge.net Computer Memory Register Domains ... Mac Book Shelf
    The journal of Macintosh technology
    Magazine In Print About MacTech Home Page Subscribe MacTech CD ... Get a copy of MacTech RISK FREE
    Entire Web
    mactech.com
    Mac Community More... MacTech Central by Category by Company by Product MacTech News MacTech News Previous News MacTech RSS Article Archives Show Indices by Volume by Author Source Code FTP Inside MacTech Writer's Kit Editorial Staff Editorial Calendar Back Issues ... Advertising Contact Us Customer Service MacTech Store Webmaster Feedback
    ADVERTISEMENT
    Volume Number: Issue Number: Column Tag: Lisp Listener
    Lambda Calculus
    Abe Lincoln
    Introduction
    Intro to l-calculus
    LISP 101
    What follows will be a crash course in LISP. or even because a list in any position can have a function position and argument positions of its own, and so on, to arbitrary depth. The next thing we need is a way to abstract out common process patterns into descriptions. This is done via lambda, the anonymous function. For instance, (lambda (x) (+ x 1)) is a function that takes in an evaluated argument, binds it with x, and then computes the body of the lambda form with the understanding that any occurrence of parameter x in the body will refer to the value of x bound by the lambda form. In this case, the returned result will be the argument plus one, and the argument will not be side effected. To invoke an anonymous function, we simply invoke it like any other function. We invoked sine like this: (sin 3). Invoking (lambda (x) (+ x 1)) on the argument 3 would look like this:

    7. Lambda Calculus
    lambda calculus is a theory of functions that is central to (theoretical) computer science. It is well known that all recursive functions are representable
    http://users.comlab.ox.ac.uk/luke.ong/teaching/lambda/
    Lambda Calculus
    C.-H. L. Ong Sixteen-hour lecture course. Final-year computer science undergraduate / MSc
    Nature and aim of the course
    Lambda calculus is a theory of functions that is central to (theoretical) computer science. It is well known that all recursive functions are representable as lambda terms: the representation is so compelling that definability in the calculus may as well be regarded as a definition of computability. This forms part of the standard foundations of computer science and mathematics. Less familiar are two separate developments one in programming, the other in proof theory in which lambda calculus has played a key role:
    • Lambda calculus is the commonly accepted basis of functional programming languages; and it is folklore that the calculus is the prototypical functional language in purified form.
    • The idea that there is a close relation between proof theory and a theory of functions is an old one. It underlies the Kolmogorov-Brouwer-Heyting interpretation of intuitionistic logic, and the Curry-Howard isomorphism between natural deduction and typed lambda calculus.
    We develop the syntax and semantics of lambda calculus along these two themes. The aim of this course is to provide the foundation for an important aspect of the semantics of programming languages with a view to helping enthusiastic research students appreciate (perhaps even begin to address) some of the open problems in the field. The second theme in particular will be followed up by two new courses

    8. Zena M. Ariola
    University of Oregon Programming languages, formal semantics, term rewriting systems, lambda calculus, compilers.
    http://www.cs.uoregon.edu/~ariola/
    Zena M. Ariola, Professor Education BS, 1980, University of Pisa, Italy
    PhD, 1992, Harvard University Research Areas Programming Languages
    Term Rewriting Systems
    lambda-calculus
    logic
  • Teaching Activities
  • Publications
    Zena M. Ariola UO Computer Science Homepage
  • 9. Good Math Has Moved To
    Lamda Calculus (Index). My Favorite Calculus Lambda (part 1) The Genius of Alonzo Church Finally, Modeling lambda calculus Programs are Pr..
    http://goodmath.blogspot.com/2006/06/lamda-calculus-index.html
    ScienceBlogs : Lamda Calculus (Index) @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
    Saturday, June 03, 2006
    Lamda Calculus (Index)
    posted by MarkCC at 3:23 PM
    0 Comments:
    Post a Comment
    Links to this post:
    See links to this post

    posted by
    Create a Link < Home
    About
    Finding the fun in good math; Shredding bad math and squashing the crackpots who espouse it.
    About Me
    Name: MarkCC
    View my complete profile
    Previous
    RSS

    10. Home Page For Kim B. Bruce
    Williams College Semantics and design of programming languages, type theory, object-oriented languages, models of higher-order lambda calculus including subtypes and bounded polymorphism.
    http://www.cs.williams.edu/~kim/
    Kim B. Bruce
    Frederick Latimer Wells Professor of CS, emeritus
    Department of Computer Science

    Williams College
    kim@cs.williams.edu
    As of 7/1/2005, I have taken a new position as Professor of Computer Science at Pomona College in Claremont, California.
    Click here to go to my new home page.
    This page will no longer be updated.
    Information is available on:
    Programming languages research.
    Computer Science Education contributions.
    Quick links to:
    Contact information
    Vita

    Recent papers

    Courses taught
    ...
    Other Interesting WWWeb sites

    My book, Foundations of Object-Oriented Languages: Types and Semantics has now been published by MIT Press.
    Recent items
    • The slides and some bonus features from my keynote to SIGCSE 2005 are now available.
    • Unfortunately, the tail end of my paper, "Controversy on How to Teach CS 1: A discussion on the SIGCSE-members mailing list," in the December, 2004, issue of Inroads, the newsletter of SIGCSE, became corrupted at the publishers. The original correct version is available here: Inroads.pdf

    11. To Dissect A Mockingbird: A Graphical Notation For The Lambda Calculus With Anim
    The lambda calculus, and the closely related theory of combinators, The lambda calculus is based on the more abstract notion of applying a function .
    http://users.bigpond.net.au/d.keenan/Lambda/index.htm
    To Dissect a Mockingbird:
    A Graphical Notation for the Lambda Calculus with Animated Reduction
    David C Keenan, 27-Aug-1996
    last updated 10-May-2001
    116 Bowman Parade, Bardon QLD 4065, Australia
    http://users.bigpond.net.au/d.keenan
    Abstract The lambda calculus, and the closely related theory of combinators, are important in the foundations of mathematics, logic and computer science. This paper provides an informal and entertaining introduction by means of an animated graphical notation. Introduction In the 1930s and 40s, around the birth of the "automatic computer", mathematicians wanted to formalise what we mean when we say some result or some function is "effectively computable", whether by machine or human. A "computer", originally, was a person who performed arithmetic calculations. The "effectively" part is included to indicate that we are not concerned with the time any particular computer might take to produce the result, so long as it would get there eventually. They wanted to find the simplest possible system that could be said to compute.
    Several such systems were invented and for the most part looked entirely unlike each other. Remarkably, they were all eventually shown to be equivalent in the sense that any one could be made to behave like the others. Today, the best known of these are the Turing Machine, of the British mathematician Alan Turing (not to be confused with his touring machine, the bicycle of which he was so fond), and the Lambda Calculus, of the American logician Alonzo Church (1941). The Turing machine is reflected in the Von Neumann machine which describes the general form of most computing hardware today. The Lambda calculus is reflected in the programming language Lisp and its relatives which are called "functional" or "applicative" languages.

    12. Lambda Calculus And A++: Basic Concepts
    lambda calculus and A++ Basic Concepts of Lambda Expressions, Lambda Conversions and the Programming Language A++.
    http://www.lambda-bound.com/book/lambdacalc/
    Next Page: Lambda Calculus and A++: Contents Up: Back to Entry Page New book on A++ and the Lambda Calculus available! Lambda Calculus A++
    Basic Concepts
    Introduction
    The Lambda Calculus has been created by the American logician Alonzo Church in the 1930's and is documented in his works published in 1941 under the title `The Calculi of Lambda Conversion' Alonzo Church wanted to formulate a mathematical logical system and had no intent to create a programming language. The intrinsic relationship of his system to programming was discovered much later in a time in which programming of computers became an issue. The Lambda Calculus has stayed alive above all in the context of functional programming. It has gained a major importance in the area of compiler construction for functional languages like Haskell, SML, Miranda and others. In this article the importance of the Lambda Calculus is extended to non-functional languages like Java, C, and C++ as well. The article uses A++, a programming language directly derived from the Lambda Calculus, as a vehicle to demonstrate the application of the basic ideas of the Lambda Calculus in a multi-paradigm environment. As a mathematical logical system the Lambda Calculus is covered in detail in [ ] and less comprehensively but in a more readable form in [ ]. A clear account of the historical origins and basic properties of the lambda calculus is presented by Curry and Fey in their book [

    13. Honsell, Furio
    University of Udine lambda calculus; foundations, especially of informatics; type systems for OO languages; logical frameworks and formal verification of proofs, programs, and systems; semantics of programming languages and program logics; mathematical structures for semantics.
    http://www.dimi.uniud.it/~honsell/

    14. Lambda Calculus Reduction Workbench
    This system implements and visualizes various reduction strategies for the pure untyped lambda calculus. It is intended as a pedagogical tool,
    http://www.itu.dk/people/sestoft/lamreduce/index.html
    Lambda calculus reduction workbench
    This system implements and visualizes various reduction strategies for the pure untyped lambda calculus. It is intended as a pedagogical tool, and as an experiment in the programming of visual user interfaces using Standard ML and HTML.
    Syntax
    Syntactically, a variable is a sequence of letters, digits and underscores, starting with a letter. Variables which stand for abbreviations are displayed with a leading dollar sign `$'. Parentheses may be left out; they are reinserted as follows: Bindings introduce abbreviations for lambda expressions, which must be closed, except for previously defined abbreviations. This example illustrates the use of abbreviations: In fact, there are several predefined abbreviations . The lambda reducer will display the predefined abbreviations if you choose `print abbreviations' and click on `Do it'.
    Reduction strategies and tracers
    The following reduction strategies are implemented:
    • call-by-name
    • head spine reduction
    • normal order
    • call-by-value
    • applicative order
    • hybrid reduction
    The following reduction tracers are available:
    • normalize the expression, and count the number of beta reductions

    15. Luke Ong's Home Page
    Merton College, Oxford Semantics of programming languages, lambda calculus, categorical logic and type theory, game semantics, linear logic.
    http://web.comlab.ox.ac.uk/oucl/work/luke.ong/

    Luke Ong's new OUCL web page

    oucl work luke.ong
    Updated April 2004 Home Search SiteMap Feedback ... News

    16. Lambda Calculus And Lambda Calculators
    Several lambdacalculators and many applications of lambda calculus.
    http://okmij.org/ftp/Computation/lambda-calc.html
    previous next contents top
    Lambda Calculus and Lambda Calculators
    Lambda-calculators
    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.

    17. Perl Contains The Lambda-Calculus
    Lambda Calculus (pronounced `lambda calculus ) is a model of computation invented by Alonzo Church in 1934. It s analogous to Turing machines,
    http://perl.plover.com/lambda/
    Perl contains the -calculus
    -Calculus (pronounced `lambda calculus') is a model of computation invented by Alonzo Church in 1934. It's analogous to Turing machines, but it's both simpler and more practical. Where the Turing machine is something like a model of assembly language, the -calculus is a model of function application. Like Turing machines, it defines a simplified programming language that you can write real programs in. Writing Turing machine programs is like writing in assembly language, but writing -calculus programs is more like writing in a higher-level language, because it has functions. The two legal operations in the -calculus are to construct a function of one argument with a specified body, and to invoke one of these functions on an argument. What can be in the body of the function? Any legal expression, but expressions are limited to variables, function constructions, and function invocations. What can the argument be? It has to be another function; functions are all you have. With this tiny amount of machinery, we can construct a programming language that can express any computation that any other language can express. Unlike most popular programming languages, Perl is powerful enough to express the

    18. 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):

    19. The Unlambda Programming Language
    Minimalistic functional language based on the lambda calculus but lacking the Lambda operator. Tutorial, reference, GPLed interpreters available.
    http://www.madore.org/~david/programs/unlambda/
    The Unlambda Programming Language
    Unlambda: Your Functional Programming Language Nightmares Come True
    Table of contents
    • What's New in Unlambda World? Introduction
      What's New in Unlambda World?
      (If you don't know what Unlambda is, skip this section and move directly to the introduction below.) [2001/08] This page is being revised in preparation of the Unlambda 3 distribution.
      Introduction
      CyberTabloid Computer Languages Today The Hitch-Hacker's Guide to Programming
      What is Unlambda?
      Unlambda is a programming language. Nothing remarkable there. The originality of Unlambda is that it stands as the unexpected intersection of two marginal families of languages:
      • Obfuscated programming languages, of which the canonical representative is Intercal . This means that the language was deliberately built to make programming painful and difficult (i.e. fun and challenging). Functional programming languages, of which the canonical representative is Scheme (a Lisp dialect). This means that the basic object manipulated by the language (and indeed the

    20. Knights Of The Lambda Calculus
    Knights of the lambda calculus n. A semimythical organization of wizardly LISP and Scheme hackers. The name refers to a mathematical formalism invented by
    http://catb.org/jargon/html/K/Knights-of-the-Lambda-Calculus.html
    Knights of the Lambda Calculus Prev K Next
    Knights of the Lambda Calculus n.
    A semi-mythical organization of wizardly LISP and Scheme hackers. The name refers to a mathematical formalism invented by Alonzo Church, with which LISP is intimately connected. There is no enrollment list and the criteria for induction are unclear, but one well-known LISPer has been known to give out buttons and, in general, the members know who they are....
    Prev Up Next kluge up  Home  knobs

    21. Bruno Carle - Java / C++ Developer - Redirect Page
    Some samples of non commercial programming e.g. a lisp like interpreter, lambda calculus interpreter, regular expression tool, and more useless stuff with C++ and Java sources. CV in english, spanish, french and italian languages.
    http://brunocarle.free.fr
    P lease wait while beeing redirected to the main page...
    F rom this site you can download my resume , and some demos in Java, C++, Javascript and php.
    You may wish to try a plain HTML version of this site

    22. Lambda Calculus -- From Wolfram MathWorld
    In the lambda calculus, lambda is defined as the abstraction operator. To H. B. Curry Essays on Combinatory Logic, lambda calculus and Formalism.
    http://mathworld.wolfram.com/LambdaCalculus.html
    Search Site Algebra
    Applied Mathematics

    Calculus and Analysis
    ... General Logic
    Lambda Calculus A formal logic developed by Alonzo Church and Stephen Kleene to address the computable number problem. In the lambda calculus, is defined as the abstraction operator . Three theorems of lambda calculus are -conversion, -conversion, and -conversion. Lambda-reduction (also called lambda conversion) refers to all three. SEE ALSO: Abstraction Operator Combinator Combinatory Logic Computable Number ... [Pages Linking Here] REFERENCES: Barendregt, H. P. The Lambda Calculus. Amsterdam, Netherlands: North-Holland, 1981. Hankin, C. Lambda Calculi: A Guide for Computer Scientists. Oxford, England: Oxford University Press, 1995. Hindley, J. R. and Seldin, J. P. Introduction to Combinators and -Calculus. Cambridge, England: Cambridge University Press, 1986. Penrose, R. The Emperor's New Mind: Concerning Computers, Minds, and the Laws of Physics. Oxford, England: Oxford University Press, pp. 66-70, 1989. Lambda-Calculus, Combinators, and Functional Programming. Cambridge, England: Cambridge University Press, 1988. Seldin, J. P. and Hindley, J. R. (Eds.).

    23. Afdeling Informatica, Faculteit Der Exacte Wetenschappen, Vrije Universiteit Ams
    Division of Mathematics and Computer Science. Research interests center around software engineering; parallel and distributed systems, including programming, distributed shared objects, operating systems support, and wide area cluster computing; agent technology; computational intelligence; knowledge representation and reasoning; lambda calculus; programming language semantics; type theory; and proof checking.
    http://www.cs.vu.nl/
    Informatica
    home
    Informatica is overal!
    Informatica gaat over informatie en de manieren waarop je informatie kunt bewerken en verwerken. Daar komt enorm veel bij kijken. Informatica is, jong als het is, dan ook al uitgegroeid tot een breed en interessant vakgebied. De informatica opleidingen aan de Vrije Universiteit bestrijken een groot deel van dat vakgebied: computersystemen, software engineering, formele methoden, kunstmatige intelligentie, bedrijfsinformatica, bedrijfswiskunde, bioinformatica . Wij zijn op zoek naar goede en gemotiveerde studenten voor de bacheloropleidingen informatica, kunstmatige intelligentie en informatiekunde. Welke opleiding het meest geschikt voor je is hangt af van waar je het accent wilt leggen. Verdere specialisatie volgt in de masterfase.
    Wil je meer weten over informatica, kunstmatige intelligentie of informatie, multimedia en management? Kijk op de paginas over onze opleidingen, of ontmoet ons bij een van onze voorlichtingsactiviteiten!

    24. John's Combinatory Logic Playground
    Pictured above you can see on the left the 210 bit binary lambda calculus selfinterpreter, and on the right the 272 bit binary combinatory logic
    http://www.cwi.nl/~tromp/cl/cl.html
    John's
    Lambda Calculus
    and
    Combinatory Logic
    Playground
    Pictured above you can see on the left the 210 bit binary lambda calculus self-interpreter, and on the right the 272 bit binary combinatory logic self-interpreter Both are explained in detail in my latest paper available in PostScript and PDF . This design of a minimalistic universal computer was motivated by my desire to come up with a concrete definition of Kolmogorov Complexity , which studies randomness of individual objects. All ideas in the paper have been implemented in the the wonderfully elegant Haskell language, which is basically pure typed lambda calculus with lots of syntactic sugar on top. The implementation also offers a Main module that lets you run the universal binary lambda computer on the command-line argument joined to standard input as a list of bytes: main = do [program] The first example is the half-byte program for identity=^x.x, while the second is the ten-and-a-half-byte program for stutter=^l l(^h^t^n^z z h (^z z h (stutter t)))nil. This online course at Oberlin College provides a very readable introduction to combinators.

    25. Better Scheme
    Language designed and largely implemented, now a matter of coding, documenting. Goals high consistency; improve language's functional nature; consistency with lambda calculus; optimize, but not at cost of other goals.
    http://www.cs.oberlin.edu/~jwalker/bscheme/
    Better Scheme
    A Jeffery Walker Programming Language
    Project Status: The language is designed and largely implemented, now it is a matter of coding and documenting. jwalker@cs.oberlin.edu

    26. Peter Selinger Papers
    Such a lambda calculus was used by Selinger and Valiron as the backbone of a functional A lambda calculus for quantum computation with classical control
    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:
    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

    27. Alligator Eggs!
    This game represents the untyped lambda calculus. A hungry alligator is a lambda abstraction, an old alligator is parentheses, and eggs are variables.
    http://worrydream.com/AlligatorEggs/
    Alligator Eggs!
    A puzzle game by Bret Victor / May 1, 2007
    Japanese translation
    Materials
    Step 1 : Print out this PDF onto six or so different colored sheets of paper
    (Even better, photocopy it onto cardstock.) Step 2 : Print out this PDF onto a couple white sheets of paper. Step 3 : Cut out the pieces!
    Pieces
    These are hungry alligators Hungry alligators are hungry . They'll eat anything that's in front of them! But they are also responsible alligators, so they guard their families. These are old alligators Old alligators are not hungry. They've eaten enough. All they do is guard their families. These are eggs Eggs hatch into new families of alligators!
    Families
    Here's a small family: A green alligator is guarding her green egg. Here's a slightly bigger family: A green alligator and red alligator are guarding a green egg and a red egg. Or, you could say that the green alligator is guarding the red alligator, and the red alligator is guarding the eggs. Here's a huge family! We've got yellow, green, red alligators guarding this family. They are guarding three things: a green egg, an old alligator, and a red egg. The old alligator is guarding a yellow egg and a green egg. Notice that eggs only use the colors of the alligators guarding them. You can't have a blue egg without there being a blue alligator around to guard it.

    28. Luke Ong
    Merton College, Oxford Categorical logic, game semantics, type theory, lambda calculus, semantics of programming languages, and sequentiality.
    http://web.comlab.ox.ac.uk/oucl/people/luke.ong.html
    Luke Ong
    Professor of Computer Science
    Tutorial Fellow in Computation, Merton College
    Address
    Oxford University Computing Laboratory
    Wolfson Building,
    Parks Road,
    Oxford, OX1 3QD,
    England.
    Telephone
    Direct: +44 (0)1865 283522
    Department: +44 (0)1865 273838
    Fax: +44 (0)1865 273839
    EMail
    Luke.Ong@comlab.ox.ac.uk
    WWW
    Work-related information (OUCL)
    Personal Information
    (Personal page,
    content is not the responsibility of OUCL)
    oucl people Updated December 2007 Home Search SiteMap Feedback ... News

    29. » Simple Lambda Calculus In Prolog - Ha4 Haskell, Hacking
    Below I take one of the possible directions to solve this embed a lambda calculus interpreter in Prolog. Look at this common paradigm
    http://ha4.fajno.net/2007/12/14/simple-lambda-calculus-in-prolog/

    30. Stochastic Lambda Calculus And Monads Of Probability Distributions (Abstract)
    Probability distributions form a monad, and the monadic definition leads to a simple, natural semantics for a stochastic lambda calculus, as well as simple,
    http://www.eecs.harvard.edu/~nr/pubs/pmonad-abstract.html
    Stochastic Lambda Calculus and Monads of Probability Distributions
    Norman Ramsey and Avi Pfeffer
    Probability distributions are useful for expressing the meanings of probabilistic languages, which support formal modeling of and reasoning about uncertainty. Probability distributions form a monad, and the monadic definition leads to a simple, natural semantics for a stochastic lambda calculus, as well as simple, clean implementations of common queries. But the monadic implementation of the expectation query can be much less efficient than current best practices in probabilistic modeling. We therefore present a language of measure terms , which can not only denote discrete probability distributions but can also support the best known modeling techniques. We give a translation of stochastic lambda calculus into measure terms. Whether one translates into the probability monad or into measure terms, the results of the translations denote the same probability distribution.
    Full paper
    The paper is available as US Letter PostScript US Letter PDF (289K-may be flaky), and

    31. Présentation De Laurent Regnier
    University of Marseilles Linear logic, lambda calculus and abstract machine interpretations.
    http://iml.univ-mrs.fr/~regnier/
    Laurent Regnier
    Téléphone :
    • bureau +33 4 91 26 96 42 fax +33 4 91 26 96 55
    Adresse électronique : regnier à iml point univ-mrs point fr Publications Enseignements (notes de cours, exos, etc.).
    Responsabilités

    32. [quant-ph/0307150] A Lambda Calculus For Quantum Computation
    Abstract The classical lambda calculus may be regarded both as a programming language and as a formal algebraic system for reasoning about computation.
    http://arxiv.org/abs/quant-ph/0307150
    arXiv.org quant-ph
    Search or Article-id Help Advanced search All papers Titles Authors Abstracts Full text Help pages
    Full-text links: Download:
    Citations 2 trackbacks p revious ... ext
    Quantum Physics
    Title: A Lambda Calculus for Quantum Computation
    Authors: Andre van Tonder (Submitted on 21 Jul 2003 ( ), last revised 3 Apr 2004 (this version, v5)) Abstract: The classical lambda calculus may be regarded both as a programming language and as a formal algebraic system for reasoning about computation. It provides a computational model equivalent to the Turing machine, and continues to be of enormous benefit in the classical theory of computation. We propose that quantum computation, like its classical counterpart, may benefit from a version of the lambda calculus suitable for expressing and reasoning about quantum algorithms. In this paper we develop a quantum lambda calculus as an alternative model of quantum computation, which combines some of the benefits of both the quantum Turing machine and the quantum circuit models. The calculus turns out to be closely related to the linear lambda calculi used in the study of Linear Logic. We set up a computational model and an equational proof system for this calculus, and we argue that it is equivalent to the quantum Turing machine. Comments: To appear in SIAM Journal on Computing. Minor corrections and improvements. Simulator available at

    33. Mathematical Sciences, Richard Statman
    Carnegie Mellon University Theory of computation, lambda calculus, combinatory logic.
    http://www.math.cmu.edu/people/fac/statman.html
    Faculty
    Visiting Faculty

    Staff

    Graduate Students
    ...
    Home
    Richard Statman
    Professor
    Ph.D., Stanford University Office: Wean Hall 7214
    Phone: (412) 268-8475
    E-mail: statman@cs.cmu.edu
    Research
    My principal research interests lie in the theory of computation with special emphasis on symbolic computation. In particular, my current research involves lambda calculus and combinatory algebra. This area underwent extensive development in the first half of this century, and then lay dormant until Dana Scott's fundamental work in the 1970's. Part of what has emerged from Scott's work is that lambda calculus forms the foundation of functional programming at both the semantic and syntactic levels. As a result, the area has been revived by an influx of theoretical problems directly related to design and implementation issues.
    Selected Publications
    The omega rule is sigma-zero-three hard (with Benedetto Intrigilia), LICS'04 On the lambda Y calculus, LICS '02 Church's lambda delta calculus, LPR '00 The word problem for combinators, RTA '00

    34. 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

    35. Stewart, Charles
    Technische Universit¤t Berlin, Theory and Formal Specifications group Proof theoretic semantics, lambda calculus, linear logic, theoretical computer science, philosophy of language.
    http://www.linearity.org/cas/

    36. 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:

    37. From Lambda To Language
    But it does show how the language machine relates to the lambda calculus and to The lambda calculus, as is very well known, is a deceptively simple
    http://languagemachine.sourceforge.net/lambda.html
    Gnu FDL - code license Gnu GPL validate HTML from lambda to language
    introduction
    This experiment shows that the language machine can operate directly as an evaluator for the lambda calculus . This is of course an academic exercise. As can be seen in the discussion below on the representation of data, the language machine has its own way of doing things. But it does show how the language machine relates to the lambda calculus and to functional languages in general, and that it is in effect a machine for computation and grammar. In particular it shows that rules which implement functional evaluation are a subset of the rules that can usefully be applied by the language machine
    the lambda calculus
    The lambda calculus , as is very well known, is a deceptively simple system that is Turing-complete , theoretically capable of computing whatever can be computed. It is not the simplest complete system (see here and here ), but the others are directly related to it, and some are deliberately designed to hurt the contents of your head . The calculus itself is very completely described in the articles linked to above. The notation used here adopts lexical conventions similar to those used in the lmn metalanguage - units of compilation are terminated by a semi-colon, lines of source text are preceded by at least one space, and any other material is treated as comment that may contain markup in a subset of the mediawiki format. The main lambda source files considered in this experiment are

    38. Homepage Henk Barendregt
    Radboud University Nijmegen lambda calculus, type theory and formalising mathematical vernacular.
    http://www.cs.ru.nl/~henk/
    Henk Barendregt Chair Foundations of
    Mathematics and Computer Science

    Radboud University, Nijmegen
    The Netherlands Picture by Amber Beckers (July 2005) Henk Barendregt (1947) holds the chair of Foundations of Mathematics and Computer Science at Nijmegen University, The Netherlands, and is adjunkt professor at Carnegie Mellon University, Pittsburgh Pennsylvania, USA. He studied at Utrecht University mathematical logic, obtaining under his Masters in 1968 and his Ph.D. in 1971, both cum laude and Since 1986 he is professor at Nijmegen University, where he and his group work on Formal Mathematics , a technology based on the idea of AUTOmated verification of MATHematics program of N. G. de Bruijn. For a list of results see the list of Freek Weedijk. Awards Barendregt was elected member of the Academia Europaea Koninklijke Hollandsche Maatschappij der Wetenschappen (1995) and the Royal Dutch Academy of Sciences (1997). In 1998 he obtained a generous seven year grant of the Board of Directors of Nijmegen university. In 2002 he was knighted in the Orde van de Nederlandse Leeuw . Barendregt obtained on February 6, 2003 the NWO Spinoza Award 2002, the highest scientific award in the Netherlands.

    39. Church
    This module allows simple experimentation with the lambda calculus, first developed by Church. It understands the different types of lambda expressions,
    http://www.alcyone.com/pyos/church/
    Table of Contents church
    Summary
    This module allows simple experimentation with the lambda calculus, first developed by Church. It understands the different types of lambda expressions, can extract lists of variables (both free and bound) and subterms, and can simplify complicated by expression by means of application.
    Getting the software
    The software is available in a tarball here: http://www.alcyone.com/pyos/church/church-latest.tar.gz The official URL for this Web site is http://www.alcyone.com/pyos/church/
    Notation
    Notations for lambda expressions vary slightly, so it is instructive to detail the precise notation used by this module. A variable is expressed with a string of alphanumeric characters, e.g. x or . There are three types of lambda expressions:
    variable expression
    A variable expression is simply an expression consisting of a single variable, e.g. x
    lambda expression
    where x is a variable and M is an expression. Repeated variables are equivalent to recursed lambda expressions, so is equivalent to
    application expression
    An application expression consists of two or more adjacent expressions surrounded by parentheses: (M N) , where M and N are expressions. Applications are left associative, so

    40. LtU Classic Archives
    lambda calculus. Shows how to reduce a subset of Scheme to LC. If you know a little Lisp/Scheme, and ever wondered what (lambda (x) (x x)) might be good for
    http://lambda-the-ultimate.org/classic/message10113.html
    Lambda the Ultimate
    Lambda Calculus
    started 11/27/2003; 9:02:07 AM - last post 11/28/2003; 3:51:20 AM Manuel Simoni - Lambda Calculus
    11/27/2003; 9:02:07 AM (reads: 10678, responses: 3) Lambda Calculus Shows how to reduce a subset of Scheme to LC. If you know a little Lisp/Scheme, and ever wondered what (lambda (x) (x x)) might be good for, this is for you. From Shiram Krishnamurti's lecture notes
    Posted to functional by Manuel Simoni on 11/27/03; 9:03:48 AM
    Manuel Simoni
    - Re: Lambda Calculus
    11/27/2003; 9:12:34 AM (reads: 441, responses: 0) Should be Shriram Krishnamurthi, sorry. Andris Birkmanis - Re: Lambda Calculus
    11/28/2003; 3:37:38 AM (reads: 312, responses: 1) Is lazy evaluation covered in some other note? Or the note just assumes we started from the lazy Scheme in the first place? Ehud Lamm - Re: Lambda Calculus
    11/28/2003; 3:51:20 AM (reads: 316, responses: 0) I haven't looked at these notes yet, but when I present a similar thing (Scheme -> LC) in my course, I repeatedly mention this fact, especially when I discuss normal order evaluation and again when I present applicative order evaluation. I also conclude by mentioning that the substitution model breaks down in the presence of assignment.

    41. 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.

    42. The Lambda Calculus - Elsevier
    The various classes of lambda calculus models are described in a uniform manner. Some didactical improvements have been made to this edition.
    http://www.elsevier.com/wps/product/cws_home/501727

    43. PlanetMath: Lambda Calculus
    In pure lambda calculus, there are no constants. Instead, there are only lambda abstractions (which are simply specifications of functions), variables,
    http://planetmath.org/encyclopedia/LambdaCalculus.html
    (more info) Math for the people, by the people. Encyclopedia Requests Forums Docs ... RSS Login create new user name: pass: forget your password? Main Menu sections Encyclop¦dia
    Papers

    Books

    Expositions

    meta Requests
    Orphanage

    Unclass'd

    Unproven
    ...
    Classification

    talkback Polls
    Forums
    Feedback Bug Reports downloads Snapshots PM Book information News Docs Wiki ChangeLog ... About lambda calculus (Definition) Lambda calculus (often referred to as -calculus) was invented in the 1930s by Alonzo Church, as a form of mathematical logic dealing primarly with functions and the application of functions to their arguments . In pure lambda calculus , there are no constants . Instead, there are only lambda abstractions (which are simply specifications of functions), variables , and applications of functions to functions. For instance, Church integers are used as a substitute for actual constants representing integers A lambda abstraction is typically specified using a lambda expression , which might look like the following. The above specifies a function of one argument, that can be reduced by applying the function to its argument (function application is left-associative by default, and parentheses can be used to specify

    44. Lambda Calculus
    But you do not need to know lambda calculus to be impressed by this program! See the file fanf.lambda for more examples of lambda calculus source.
    http://www.ioccc.org/1998/fanf.hint

    45. Into The Wibble [lambda-calculus]
    This page is all about my lambda computer a program that computes in the lambda calculus. For fun, I also did a Turing machine in lambda calculus (fairly
    http://frmb.org/lambda.html
    Fred's Home Page
    Main
    About me
    csh is bad Debian ... XHPD
    Lambda calculus
    intro basic lists recursion ... download This page is all about my lambda computer a program that computes in the lambda calculus. For fun, I also did a Turing machine in lambda calculus (fairly trivial representation). Introduction The lambda calculus is basically function theory, there are only three things available in the pure lambda calculus, these are: Variables a the variable a Applications (a b) a applied to b Abstractions function e with argument x Dispite not being very much here, the expressive power is quite suprising. Using these three simple things, numbers, lists, recursion and much more can be defined. This page is not intended to be an introduction to the lambda calculus; there are lots of good books for that. One excellent one is Barendregt's "The Lambda Calculus : its syntax and semantics". ISBN: 0444875085 (paper-back) and 0444867481 (hard-back). It's rather mathematically extreme though...
    • Acknowledgement: Most of the terms here are from the CO611 (types and computation) course at Kent Uni, kindly taught by Stefan Kahrs and Simon Thompson. The type-theory computing program may happen at some point too..
    Here is a picture of the program running.

    46. Notes: Lambda Calculus
    lambda calculus as a basis for functional programming languages More Lambda notes lambda calculus is a formal model of computation. Others include
    http://www.cs.unc.edu/~stotts/723/Lambda/
    Lambda Calculus
    Lambda Calculus Interpreter
    Fun to try after you learn the basics of the syntax
    Notes
    Lambda Calculus
    Let's examine some of the theoretical foundations of computation, specifically functional computation. You may wish to read early parts of this paper:
  • Cardelli and Wegner, "On Understanding Types, Data Abstraction, and Polymorphism" Notes we will refer to Encoding Lambda calculus in ML Boolean values and operators
    ML code: booleans
    Church numerals ... And More Lambda notes
    Lambda calculus is a formal model of computation. Others include
    • Turing Machine
    • Post production system (phrase-structure, unrestricted, type-0 grammars)
    • Graph/Net models
      • Petri-nets with inhibitor arcs
      • predicate/transition nets
      • debit-nets under forced anihilation
    • Relational model (resolution/unification, Prolog basis)
    • Theory of recursive functions
    Basics:
    • variables are lambda-expressions (lexp)
    • lambda abstractions (function definitions) are lexp
    • function applications are lexp
    For example:
    • variables: a, x, foo, bar
    • lambda abstraction: lambda x 2*x
    • function application: ( (lambda x 2*x) 5 ) specifies value 10
    Syntax examples for lambda-expressions
    x a single variable lambda x x a function abstraction with one argument (x) and the body "x" (x y) function application where function lexp "x" is applied to arg lexp "y" (lambda x x y) function "lambda x x" applied to "y" lambda x (x y) function abstraction with one variable "x" and body "(x y)" which is a function application
  • 47. Lambda Calculus Implementatie
    Untyped lambda calculus. *) (* *) (* Freek Wiedijk, University of Nijmegen .. lambda.ml ;; *) (* val id a a = fun *) (* val ( ** ) ( a - b)
    http://www.cs.ru.nl/~freek/notes/lambda.ml
    *) (* val ( ** ) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b = *) (* val index : 'a -> 'a list -> int = *) (* val implode : string list -> string = *) (* val lex : string list -> string list = *) (* val parse : string list -> term = *) (* val term : string -> term = *) (* val term_to_string : term -> string = *) (* val alpha : term -> term = *) (* val print_term : term -> unit = *) (* val combinators : (string * term) list = *) (* [("I", term "^x.x"); ("K", term "^xy.x"); ("S", term "^xyz.xz(yz)"); *) (* ("B", term "^xyz.x(yz)"); ("C", term "^xyz.xzy"); ("1", term "^xy.xy") *) (* ("Y", term "^f.(^x.f(xx))^x.f(xx)"); ("T", term "^xy.x"); *) (* ("F", term "^xy.y"); ("J", term "^abcd.ab(adc)")] *) (* val unfold : term -> term = *) (* val lift : int -> int -> term -> term = *) (* val subst : int -> term -> term -> term = *) (* exception Normal *) (* val maybe : ('a -> 'a) -> 'a -> 'a = *) (* val beta : (term -> term) -> term -> term =

    48. Pure Lambda Calculus
    This is a description of the Content Scramble System (CSS) ;; descrambling algorithm in the pure lambda calculus. At the same ;; time it is also a valid
    http://www.cs.cmu.edu/~dst/DeCSS/Gallery/css-descramble-lambda.txt
    < subfunctions ((lambda (reversed-join generalized-filter z4 z8 z1920 zxor) ; < more subfunctions ((lambda (stream->bitstream bitstream->stream xor-bitstreams) ; < more subfunctions ((lambda (test-encryption-flag get-sector-key crypt) ; < subfunctions (lambda (key sector-body) (xor-bitstreams (z* z8 z1920) (unmangle sector-body) (cipher-bitstream key)) )) ;; ================ ;; cipher-bitstream ;; ================ ;; This function returns the pseudo-random bitstream generated ;; by the given key. The random number generator uses two ;; LFSRs, one of 17 bits and the other of 25 bits, initialized ;; from the "key" argument. The outputs of the two LFSRs are ;; added together (with carry) to produce the final result. ;; The 17-bit LFSR's output is negated before the addition. ((lambda (tap-lfsr17 tap-lfsr25 make-bitstream negate-bitstream add-bitstreams) ; < subfunctions (lambda (n stream) (generalized-filter stream n (lambda (s tail) (byte->bitstream (zcar s) tail) ) zcdr z1 ))) ;; =============== ;; byte->bitstream ;; =============== ((lambda (shift) ;

    49. A Lambda Calculus For Quantum Computation
    which develop a linear lambda calculus for expressing quantum algorithms. The code below implements the examples in the first one of these two papers.
    http://www.het.brown.edu/people/andre/qlambda/index.html
    A lambda calculus for quantum computation
    Scheme simulator
    This page provides a simulator for a functional language based on Scheme for expressing and simulating quantum algorithms. Example code implementing some simple quantum algorithms is provided. For the theory, see my papers which develop a linear lambda calculus for expressing quantum algorithms. The code below implements the examples in the first one of these two papers.
    Instructions
    The code should work in any Scheme adhering to the R5RS standard. It has been tested in PLT's DrScheme and Petite Chez Scheme, both of which are freely available. Instructions are as follows for DrScheme:
    • Install DrScheme . When asked during installation, choose the "Pretty Big" language level. Save the two files wherever you like, but they should be in the same directory. Launch DrScheme, load the file quantum.scm, and click on the "execute" button to run the algorithms.
    Examples:
    Simple gate combinations
    First let's apply a few Hadamard gates in sequence to a single qubit. The QEVAL performs the sum over histories:

    50. The Lambda Calculus
    The lambda calculus was created by Alonzo Church in the 1930s as a construction in abstract logic but has had practical application in the design of
    http://www.sjsu.edu/faculty/watkins/lambda.htm
    applet-magic.com
    Thayer Watkins
    Silicon Valley
    USA The Lambda Calculus
    The Lambda Calculus was created by Alonzo Church in the 1930s as a construction in abstract logic but has had practical application in the design of programming languages, most notably LISP. The Lambda Calculus involves the evaluation of lambda expressions, which are definitions of unnamed functions. The format of a lambda expression is:

    lambda [parameter list]. [body of function]
    where the body of a function is just the rules for computing the function's value. For example, the function of taking the square of a number is expressed in lambda notation as:

    lambda x . x*x
    Students encountering the lambda notation in LISP are often puzzled as to why it is needed. The lambda notation is essential for several reasons. First there is a need for a means of defining a function without giving it a name. Naming functions is an easy task but there is an arbitrariness to choosing a name that does not fit in well with computer processing. Functions could be named serially in the order in which they arise in a program. This is feasible but awkward. Often there is not real need for a function to have a name. So the lambda notation handles the problem of creating functions without naming them. Of course function can be given names to facilitate reference to them if that is needed. The power of the lambda notation is in its generality. The lambda notation will handle the case in which the value of a function is a function. In many computer languages the value of a function must be an element of a set, such as a number or a string or the label of a function. In the lambda notation the value can be a function, not the name or label of a function but a function itself.

    51. Lecture About Scheme And Lambda Calculus
    This is a presentation that introduces the Scheme programming language, and then uses the learned subset to demonstrate lambda calculus. lambda calculus is
    http://www.shlomifish.org/lecture/Lambda-Calculus/
    Go to main content google_ad_client = "pub-2480595666283917"; google_ad_width = 125; google_ad_height = 125; google_ad_format = "125x125_as"; google_ad_type = "text_image"; google_ad_channel =""; google_color_border = "336699"; google_color_bg = "FFFFFF"; google_color_link = "000000"; google_color_text = "0000FF"; google_color_url = "008000"; Shlomi Fish Lectures Programming Languages Go to the navigation menu ...
    External resources

    WWW
    shlomifish.org
    Like this site? Please Help

    google_ad_client = "pub-2480595666283917"; google_ad_width = 120; google_ad_height = 600; google_ad_format = "120x600_as"; google_ad_type = "text"; google_ad_channel =""; google_color_border = "008000"; google_color_text = "6F6F6F"; google_color_bg = "FFFFFF"; google_color_link = "0000CC"; google_color_url = "008000";
    Lectures Section Menu
    Hide
    Lecture about Scheme and Lambda Calculus
    This is a presentation that introduces the Scheme programming language , and then uses the learned subset to demonstrate Lambda Calculus. Lambda Calculus is a mathematical model of computation, which only has two primitives and yet is still quite usable and fun.
    The Slides
    Written, designed and maintained by Shlomi Fish

    52. Lambda Calculus Basics
    lambda calculus Basics including its history, its definition and the basic rules.
    http://www.aplusplus.net/lcintro.html
    The Lambda Calculus
    Origin
    The Lambda Calculus has been created by the American logician Alonzo Church in the 1930's and is documented in his works published in 1941 under the title `The Calculi of Lambda Conversion' Alonzo Church wanted to formulate a mathematical logical system and had no intent to create a programming language. The intrinsic relationship of his system to programming was discovered much later in a time in which programming of computers became an issue.
    Definition
    Syntax of Lambda Expressions
    The syntax of lambda expressions is defined as follows: The Lambda Calculus therefore includes three diffenrent types of lambda expressions:
    • variables (referencing lambda expressions) lambda abstractions (defining functions) applications (invoking functions, performing a synthesis of two lambda expressions)
    Remark: The parentheses in the syntax of an application are not mandatory. This results from the law of associativity for applications introduced below.
    More Details
    For a detailed introduction to the Calculi of Lambda Conversion see Appendix B of the online version of the A++ book. For the reader's convenience a PDF-Version of this article is also available

    53. LCI - A Lambda Calculus Interpreter
    LCI is an interpreter for the lambda calculus. It supports many advanced features like recursion, userdefined operators and multiple evaluation strategies,
    http://lci.sourceforge.net/
    LCI Home Page news download documentation more info
    What is LCI? LCI is an interpreter for the lambda calculus. It supports many advanced features like recursion, user-defined operators and multiple evaluation strategies, all based on the pure calculus. It is FREE SOFTWARE licenced under the GNU General Public Licence (GPL). News
    • Version 0.5 is out (13 March 2006)
      First 'official' release of lci, the code was there for some time but I wanted to add an autotooled build system and some cool extra features.
      There is also support for readline now so if you have it installed when compiling you'll be able to edit the lines that you type, have history, etc.
      Finally some impressive optimizations have been done in this version. Queens 5 takes just 2 seconds instead of 50 and we can even solve Queens 6 and Queens 7 which were unsolvable before.
      Enjoy :)
    Download Latest version is 0.5, released on 13 March 2006. You can install LCI from source (recommended) or you can use the pre-compiled i386 binaries for Linux and Windows.

    54. Lambda Calculus And Combinators
    The lambda calculus is an elegant formulation of the classical idea. The lambda calculus was introduced as a notation for representing and studying
    http://cs.wwc.edu/KU/Logic/lambdaCalculus.html

    55. CiteULike: A Lambda Calculus For Quantum Computation
    The classical lambda calculus may be regarded both as a programming language and as a formal algebraic system for reasoning about computation.
    http://www.citeulike.org/user/bendiken/article/216792
    Register Log in FAQ
    CiteULike
    Journals
    Groups
    • Search groups Profile Library Watchlist ... Import
      A Lambda Calculus for Quantum Computation
      Authors
      Online Article
      Note: You or your institution must have access rights to this article. CiteULike will not help you view an online article which you aren't authorized to view.
      Copy-and-Pasteable Citation
      (3 April 2004) Citation format: Plain APA Chicago Elsevier Harvard MLA Nature Oxford Science Turabian Vancouver
      bendiken's tags for this article
      Other users who have posted this article
      Everyone's tags for this article
      Abstract
      The classical lambda calculus may be regarded both as a programming language and as a formal algebraic system for reasoning about computation. It provides a computational model equivalent to the Turing machine, and continues to be of enormous benefit in the classical theory of computation. We propose that quantum computation, like its classical counterpart, may benefit from a version of the lambda calculus suitable for expressing and reasoning about quantum algorithms. In this paper we develop a quantum lambda calculus as an alternative model of quantum computation, which combines some of the benefits of both the quantum Turing machine and the quantum circuit models. The calculus turns out to be closely related to the linear lambda calculi used in the study of Linear Logic. We set up a computational model and an equational proof system for this calculus, and we argue that it is equivalent to the quantum Turing machine.

    56. Lambda Calculus Plus Letrec
    The scoped lambdagraphs are represented by terms defined over lambda calculus extended with the letrec construct. On this set of terms we define a sound
    http://www.cs.uoregon.edu/~ariola/cycles.html
    Lambda calculus plus letrec
    The paper consists of three parts.
    Part I:
    We establish an isomorphism between the well-formed cyclic lambda-graphs and their syntactic representations. To define the well-formed cyclic lambda-graphs we introduce the notion of a scoped lambda-graph. The well-formed lambda-graphs are those that have associated scoped lambda-graphs. The scoped lambda-graphs are represented by terms defined over lambda calculus extended with the letrec construct. On this set of terms we define a sound and complete axiom system (the representational calculus) that equates different representations of the same scoped lambda-graph. Since a well-formed lambda-graph can have different scoped lambda-graphs associated to it, we extend the representational calculus with axioms that equate different representations of the same well-formed graph. Finally, we consider the unwinding of well-formed graphs to possibly infinite trees and give a sound and complete axiomatization of tree unwinding.
    Part II:
    We add computational power to our graphs and terms by defining beta-reduction on scoped lambda-graphs and its associated notion on terms. The representational axiom system developed in the first part combined with beta-reduction constitutes our cyclic extension of lambda calculus. In contrast to current theories, which impose restrictions on where the rewriting can take place, our reduction theory is very liberal, e.g. it allows rewriting under lambda-abstractions and on cycles. As shown previously, the reduction theory is non-confluent. We thus introduce an approximate notion of confluence, which guarantees uniqueness of infinite normal forms. We show that the infinite normal form defines a congruence on the set of terms. We relate our cyclic lambda calculus to the plain lambda calculus and to the infinitary lambda calculi. We conclude by presenting a variant of our cyclic lambda calculus, which follows the tradition of the explicit substitution calculi.

    57. Lambda Calculus Interpreter
    Shows the steps made throughout the evaluation of the lambda calculus expression EXP. (when (bufferlive-p lc-step-buffer) (kill-buffer lc-step-buffer))
    http://mwolson.org/static/dist/elisp/lambdacalc.el
    with the desired expression. ;; ;; M-x lc-eval-expression RET ( ) RET ;; ;; Note that the expression must be surrounded by a set of ;; parentheses. Omit the period in `lambda' constructs. ;; ;; To define a metavariable, evaluate the following code, replacing ;; with the name of the metavariable, and with ;; the desired expression. ;; ;; (lc-def )) ;; ;; If you wish to evaluate lambda calculus expressions ;; programmatically, you can use the `lc-eval' macro, which takes ;; something of the form ( ). There is no need to quote ;; the expression. ;; ;; To see each individual step of the evaluation process, do the ;; following. By default, the expressions are pretty-printed; to ;; change that, customize the `lc-enable-pp' option. ;; ;; M-x lc-step-expression RET ( , but were modified to use a ;; single-argument lambda form. ;; ;; Thanks go to Riastradh on #emacs for suggesting that I use ;; functions rather than the macro mess I previously had. ;; * Endorsements: ;; ;; From an IRC chat on #hcoop: ;; ;; i'm currently making a lambda calculus interpreter in ;; Emacs Lisp ;; * Smerdyakov gags. :D ;; ;; From an IRC chat on #emacs: ;; ;; * mwolson is tantalizingly close to having the final piece of his ;; lambda calculus interpreter (in Emacs Lisp) done ;;

    58. Foreign Dispatches: An Introduction To The Lambda Calculus
    An Introduction to the lambda calculus. And now for something different. Are you a programmer who s made a run in or two with esoteric languages like
    http://foreigndispatches.typepad.com/dispatches/2007/02/an_introduction.html
    Foreign Dispatches
    Random Remarks on Current Affairs
    Flickr
    Periodicals
    Math/IT
    References
    Politics
    Blogs
    Sitemeter
    Math Books
    Main
    February 18, 2007
    An Introduction to the Lambda Calculus
    And now for something different. Are you a programmer who's made a run in or two with esoteric languages like Haskell, Erlang and OCaml, and do you find yourself confused by closures, maddened by monads and feeling downright cantankerous whenever you hear about currying? If you are, I have a suggestion for you: instead of wasting your time struggling through yet another functional programming tutorial whose writers implicitly assume that you already understand half of the new things they're supposedly trying to teach, you'd be better off giving a close reading to a paper by Henk Barendregt and Erik Barendsen called

    59. Workshop On Lambda-Calculus, Type Theory, And Natural Language, 2005
    This page describes the second workshop on lambda calculus, Type Theory and The workshop covered aspects of the lambda calculus and its connection with
    http://lcttnl.foxearth.org/
    Please go to: http://cswww.essex.ac.uk/staff/foxcj/lcttnl/

    60. Lambda Calculus@Everything2.com
    An interesting aspect is that + and even 2 can themselves be defined in terms of lambda calculus it is a complete description of discrete computation.
    http://www.everything2.com/index.pl?node_id=122026

    61. Mechanically Separated Meat » Blog Archive » The Ballad Of The Lambda Calculus
    Church had years before Turing’s paper defined a “lambda calculus”, a sort of way of defining trees of functions that call other functions, equipped with a
    http://msm.grumpybumpers.com/?p=15

    62. Lambda Calculus
    The pure calculus appears to lack recursion (or equivalently iteration) but recursive functions can in fact be defined, as examples also demonstrate.
    http://www.allisons.org/ll/FP/Lambda/
    var REMOTE_HOST='(none)', REMOTE_ADDR='67.18.104.18';
    Lambda Calculus
    LA home
    FP

    Intro.

    Examples
    ...
    Interp.(S)

    Also see
    Prolog

    application abstraction
    Constants including integers, booleans and so on can all be defined using just the syntax above, as some of the examples demonstrate. Because of this it is sometimes convenient to extend the syntax with a fifth option of constants (0, 1, 2, ..., true, false, and, but, if that is done, it is only a convenience and does not increase the power of the language.
    Note that an abstraction defines an anonymous function.
    can in fact be defined, as examples also demonstrate

    NB. The applet above needs Java on.
    The introduction describes the semantics of and programming techniques, and the interpreter shows how it can be made to work.
    window on the wide world:
    The Darwin Awards 4:
    Intelligent Design Linux free op.-sys. OpenOffice free office-suite, ver. 2.2+. The GIMP ~ free photoshop. Firefox web browser. http://www.allisons.org/ll/ or as otherwise indicated Created with "vi (Linux + Solaris)", charset=iso-8859-1, fetched Saturday, 22-Dec-2007 17:23:11 EST.

    63. Lambda Calculus - Simple English Wikipedia, The Free Encyclopedia
    In mathematical logic and computer science, lambda calculus, also calculus, is a formal system. It was designed to investigate the definition of functions
    http://simple.wikipedia.org/wiki/Lambda_calculus
    var wgNotice = ""; var wgNoticeLocal = ""; var wgNoticeLang = "simple"; var wgNoticeProject = "wikipedia";
    Lambda calculus
    From Simple English Wikipedia - the free encyclopedia that anyone can change
    Jump to: navigation search In mathematical logic and computer science lambda calculus , also λ-calculus , is a formal system . It was designed to investigate the definition of functions , and how to apply them. It is also a tool for analysing recursion . It was introduced by Alonzo Church and Stephen Cole Kleene in the . Church used lambda calculus in 1936 to give a negative answer to the Entscheidungsproblem . Lambda calculus can be used to define what a computable function is. No general algorithm can answer the question, if two lambda calculus expressions are equivalent. This was the first question, even before the halting problem , for which undecidability could be proved. Lambda calculus has greatly influenced functional programming languages , such as LISP ML and Haskell Lambda calculus can be called the smallest universal programming language . It consists of a single transformation rule (variable substitution) and a single function definition scheme. Lambda calculus is universal in the sense that any computable function can be expressed and evaluated using this formalism. It is thus equivalent to the Turing machine formalism. However, lambda calculus emphasizes the use of transformation rules. It does not care about the actual machine that implements them. It is an approach more related to

    64. Lambda Calculus (at Safalra's Website)
    Welcome to the lambda calculus section of Safalra’s Website. This section of the website contains a brief tutorial on lambda calculus and what can be
    http://www.safalra.com/science/lambda-calculus/
    Lambda Calculus
    This article is in: The Lambda Calculus: Its Syntax And Semantics This article was last edited on 14th April 2007. The author can be contacted using the form below. Your e-mail address (a confirmation e-mail will be sent to this address): Your message: Enter your message Send message

    65. Lambda Calculus - A Definition From WhatIs.com
    lambda calculus, considered to be the mathematical basis for programming language, is a calculus developed by Alonzo Church and Stephen Kleene in the 1930s
    http://whatis.techtarget.com/definition/0,,sid9_gci341298,00.html
    lambda calculus
    Search our IT-specific encyclopedia for: or jump to a topic: Application Security CIO CRM Data Center Data Management Domino Exchange IBM S/390 IBM AS/400 IT Channel Mobile Computing Networking Networking Channel Open Source Oracle SAP Security Security Channel Server Virtualization Small Medium Business SQL Server Storage Storage Channel Systems Channel Visual Basic VoIP Web Services Windows IT Windows Security Windows Systems Advanced Search Browse alphabetically:
    A
    B C D ... Programming
    lambda calculus
    Lambda calculus, considered to be the mathematical basis for programming language, is a calculus developed by Alonzo Church and Stephen Kleene in the 1930s to express all computable�functions.� In an effort to formalize the concept of computability (also known as constructibility and effective calculability), Church and Kleene developed a powerful language with a simple� syntax and few grammar restrictions. The language deals with the application of a function to its arguments (a function is a set of rules) and expresses any entity as either a variable, the application of one function to another, or as a "lambda abstraction" (a function in which the Greek letter�lambda is defined as the abstraction operator). Lambda calculus, and the closely related theories of combinators and type systems, are important foundations in the study of mathematics, logic, and computer programming language.

    66. Call-by-Value {lambda}-calculus And LJQ -- Dyckhoff And Lengrand 17 (6): 1109 --
    Keywords lambda calculus; callby-value; sequent calculus; continuation-passing; semantics. Disclaimer Please note that abstracts for content published
    http://logcom.oxfordjournals.org/cgi/content/abstract/17/6/1109
    @import "/resource/css/hw.css"; @import "/resource/css/logcom.css"; Skip Navigation Oxford Journals
    Journal of Logic and Computation Advance Access originally published online on September 21, 2007
    Journal of Logic and Computation 2007 17(6):1109-1134; doi:10.1093/logcom/exm037
    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 Dyckhoff, R. Articles by Lengrand, S.
    Original Articles
    Call-by-Value -calculus and LJQ
    Roy Dyckhoff and School of Computer Science, University of St Andrews, St Andrews, Fife, KY16 9SX, Scotland. E-mail: Received 29 October 2006.
    Abstract LJQ is a focused sequent calculus for intuitionistic logic, with a simple restriction on the first premiss of the usual left introduction rule for implication. In a previous paper

    67. Things That Amuse Me
    In a previous blog entry I described a simple evaluator and type checker for the lambda cube, i.e., various forms of lambda calculus.
    http://augustss.blogspot.com/2007/11/some-lambda-calculus-examples-syntax-in.htm
    @import url("http://www.blogger.com/css/blog_controls.css"); @import url("http://www.blogger.com/dyn-css/authorization.css?targetBlogID=25541020");
    Things that amuse me
    Friday, November 09, 2007
    Some lambda calculus examples
    Syntax
    In a previous blog entry I described a simple evaluator and type checker for the lambda cube, i.e., various forms of lambda calculus. ; the full lambda cube is not necessary. ". And as in Haskell I'll allow multiple variables between the " " and " "; it's just a shorthand for multiple lambdas. So what about the dependent function type? The syntax suggests (x::t)->u , so I'll use that. And when the variable doesn't occur we'll write t->u as usual. For type variables Haskell (well, not Haskell 98, but extensions) uses forall (a::*) . t , so I'll allow that too. An example, the identity function: with type forall (a::*) . a->a And using it id Int 5 Writing a pretty printer and parser for this is pretty straight forward so I'll skip that and just point you to the code . BTW, instead of using Parsec for the parser like everyone else I used ReadP. The ReadP library is very nice, partly because the alternative operator is actually commutative (unlike Parsec). But the error messages suck.
    Enter let
    What makes it awkward is that the name

    68. Arithmetic In Lambda Calculus - Wolfram Demonstration Project
    lambda calculus was developed by Alonzo Church and Stephen Kleene in 1930 and consists of a single transformation rule (variable substitution) and a single
    http://demonstrations.wolfram.com/ArithmeticInLambdaCalculus/
    Arithmetic in Lambda Calculus
    loadFlash(644, 387, 'ArithmeticInLambdaCalculus'); Lambda calculus was developed by Alonzo Church and Stephen Kleene in 1930 and consists of a single transformation rule (variable substitution) and a single function definition scheme. It is a system capable of universal computation, that is, any computable function that can be computed in any of the standard programming languages can also be done in lambda calculus, though it might be very hard to actually carry out. Only the basic arithmetic operations successor, testing for zero, addition, multiplication, and exponentiation are considered here. The second numeral is not used for successor or testing for zero.
    The central concept in λ calculus is the "expression". A "name" (or "variable") is an identifier that can be any letter. An expression is defined recursively as follows: In order to apply a function to an argument by substituting the argument for a variable in the body of the function and for giving a name to the function determined by a rule, it is necessary to define the following terms: 1) The identity function: (( 2) Self-application: . Applying this to any expression expr results in (expr expr), which may or may not make sense.

    69. Jacal - Lambda Calculus
    lambda calculus. Create a lambda expression. Operator lambda varlist expression Jacal has the ability to work with lambda expressions, via the command
    http://www-swiss.ai.mit.edu/~jaffer/jacal_5.html
    Contents Back Prev Up Next Forward
    Lambda Calculus
    Create a lambda expression
    Operator: lambda varlist expression
    Jacal has the ability to work with lambda expressions, via the command lambda . Furthermore, Jacal always converts user definitions of functions by any method into lambda expressions and converts the dummy variables of the function definition into symbols such as , .... Jacal can manipulate lambda expressions by manipulating their function parts, as in below. Jacal can also invert a function using the command finv e12 : lambda([x],x^2); 2 e12: lambda([@1], @1 ) e13 : lambda([x,y,z],x*y*z); e13: lambda([@1, @2, @3], @1 @2 @3) e14 : e12+e13; 2 e14: lambda([@1, @2, @3], @1 + @1 @2 @3)
    Compute inverse function
    Command: finv function
    function The command finv takes as input a function of one variable and returns the inverse of that function. The function may be defined in any of the ways permitted in Jacal, i.e. by an explicit algebraic definition, by an explicit lambda expression or by an implicit lamba expression. If f is the function, then typing

    70. Elisp And The Lambda Calculus « Minor Emacs Wizardry
    This one is only for hardcore emacsers who are into programming languages theory a lambda calculus interpreter written in Elisp by Michael Olson. Enjoy!
    http://emacs.wordpress.com/2007/02/20/elisp-and-the-lambda-calculus/
    minor emacs wizardry
    Gnus miscellanea An illustrated Emacs tutorial
    Elisp and the Lambda Calculus
    This one is only for hardcore emacsers who are into programming languages theory: a lambda calculus interpreter written in Elisp by Michael Olson . Enjoy! This entry was posted on February 20, 2007 at 7:51 pm and is filed under Fun . You can follow any responses to this entry through the RSS 2.0 feed. You can skip to the end and leave a response. Pinging is currently not allowed.
    Leave a Reply
    Name (required) Mail (will not be published) (required) Website Blog at WordPress.com
    Entries (RSS)
    and Comments (RSS) dp.SyntaxHighlighter.ClipboardSwf = 'http://s.wordpress.com/wp-content/plugins/highlight/clipboard.swf'; dp.SyntaxHighlighter.HighlightAll('code');

    71. Wadler's Blog: John Baez On Lambda Calculus And Games
    John Baez has an intriguing introduction to lambda calculus and games. He converts a game tree into an expression built from products, exponents,
    http://wadler.blogspot.com/2006/10/john-baez-on-lambda-calculus-and-games.html
    @import url("http://www.blogger.com/css/blog_controls.css"); @import url("http://www.blogger.com/dyn-css/authorization.css?targetBlogID=9757377");
    Wadler's Blog
    John Baez on Lambda Calculus and Games John Baez has an intriguing introduction to lambda calculus and games. He converts a game tree into an expression built from products, exponents, and a single term X (hence there is a close connection to CCCs). The corresponding game is unwinnable if setting X=0 and evaluating yields (so X is an unwinnable game: there are no values of type All X.X) and winnable if evaluating yeilds 1 (so X^X is a winnable game: there is a value of type All X. X -> X). The note is a couple of pages long, and ends with a fine survey of introductory material on lambda calculus.
    posted by Philip Wadler @ 2:46 PM Comments: Post a Comment
    About Me
    Name: Philip Wadler Location: Edinburgh, United Kingdom
    View my complete profile
    Buy the book via this link and 5% goes to James Gillespies Primary School PTA
    archives

    72. Research/Lambda Calculus And Type Theory - Foundations
    The lambda calculus was originally conceived by Church in 1932 as part of a general theory of functions and logic, intended as a foundation for mathematics.
    http://www.fnds.cs.ru.nl/fndswiki/Research/Lambda_calculus_and_Type_Theory
    Search:
    Foundations Group
    of the ICIS
    • People Seminars
      Research
      Lambda calculus and Type Theory
      The lambda calculus was originally conceived by Church in 1932 as part of a general theory of functions and logic, intended as a foundation for mathematics. Although the system turned out to be inconsistent, the subsystem dealing with functions only became a succesful model for the computable functions. This system is called now the (type-free) lambda calculus. Representing computable functions as lambda terms gives rise to so called functional programming. People::
      • Henk Barendregt Wil Dekkers Herman Geuvers Jan Willem Klop Iris Loeb
      Projects::
      • Typed Lambda Calculus and Applications.
        • The aim is to produce a research monograph on typed lambda calculus with its mentioned applications. This book will serve as a sequel to Barendregt's monograph on type-free lambda calculus (North-Holland, 1984, also translated into Russian and Chinese), a classical work that is considered as the standard reference to lambda calculus. The editors and main authors of the book are Henk Barendregt and Wil Dekkers of the University of Nijmegen and Rick Statman of Carnegie Mellon University, Pittsburgh, USA. Several co-authors (all of them leading experts in the field) will contribute to this work. The project is embedded in the larger project `Lambda-calculus and Applications', a 7-year research effort at the Computing Science Institute in Nijmegen, supported by a special grant of the University Council.

    73. A Certified Type-Preserving Compiler From Lambda Calculus To Assembly Language Ã
    Vous êtes ici Accueil Rendezvous Séminaires des équipes de recherche A Certified Type-Preserving Compiler from lambda calculus to Assembly Language
    http://www-c.inria.fr/Internet/rendez-vous/seminaires-des-equipes-de-recherche/a

    Rendez-vous
    Vous ªtes ici : Accueil Rendez-vous S©minaires des ©quipes de recherche A Certified Type-Preserving Compiler from Lambda Calculus to Assembly Language
    S©minaire A Certified Type-Preserving Compiler from Lambda Calculus to Assembly Language
    Outils personnels
    par Adam Chlipala - University of California, Berkeley 22 janvier 2007   10h30
    INRIA Rocquencourt, Amphi Turing, B¢t. 1 R©sum© et informations pratiques
    GALLIUM
    et MOSCOVA
    Actualis© le 21 f©vrier 2007   17h54
    Institut national de recherche en informatique et en automatique / centre de recherche INRIA Paris-Rocquencourt
    INRIA Paris - Rocquencourt, t©l. : (+33) 1 39 63 55 11 domaine de Voluceau, BP 105, 78153 Le Chesnay Cedex France. Mentions l©gales Plan du site Contact ... Intranet

    74. Chapter 8. Boost.Lambda
    The term originates from functional programming and lambda calculus, where a lambda abstraction defines an unnamed function. The primary motivation for the
    http://www.boost.org/libs/lambda/
    Automatic redirection failed, please go to www.boost.org/doc/html/lambda.html Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at www.boost.org/LICENSE_1_0.txt

    75. [Some Citations For Lambda Calculus Books From MathSciNet Djr
    From the introduction This paper is an introduction to the typefree lambda calculus. Section 1 gives some intuition about the basic operations of the
    http://www.math.niu.edu/~rusin/known-math/99/lambdacalc_refs

    76. Marino Miculan
    University of Udine Semantics of programming languages, formal verification of process/program properties, logical frameworks based on typed lambda-calculus.
    http://www.dimi.uniud.it/~miculan/
    Marino Miculan
    Associate professor of Computer Science (INF/01) at the Faculty of Science of the University of Udine Address: Room SN3, Dipartimento di Matematica e Informatica
    - via delle Scienze, 206 - 33100 Udine - Italy.
    Phone: (+39)043255.8486, Fax: (+39)043255.8499, Skype: marinomiculan
    Email: miculan at dimi, uniud, it . (I endorse S/MIME; here is my X.509 certificate
    RESEARCH
    CONFERENCES, WORKSHOPS

    77. Pietro Di Gianantonio Home Page
    University of Udine Real number computability, semantics of concurrency, lambda-calculus.
    http://www.dimi.uniud.it/~pietro/
    Pietro Di Gianantonio
    Dipartimento di Matematica e Informatica Università di Udine
    Research
    Real number computability, semantics of programming languages, lambda-calculus, game semantics, formal proofs.
    Teaching (Didattica)
    Orario di Ricevimento:
    • mercoledì ore 13:30 - 15:30, o su appuntamento.
    office:
    2nd floor, room 1, Stecca Nord,
    phone: fax: mail:
    pietro at dimi dot uniud dot it
    address:
    Dipartimento di Matematica e Informatica Università di Udine Via delle Scienze, 206 33100 Udine - Italy

    78. Tobias Nipkow
    Technische Universit¤t M¼nchen Automatic and interactive theorem proving, formal verification, formalizing programming languages, type systems, semantics, rewriting and unification, lambda-calculus.
    http://isabelle.in.tum.de/~nipkow/
    Theorem Proving Group
    Prof. Tobias Nipkow
  • Now soliciting your submission: AFP: The Archive of Formal Proofs
  • Now out: The Isabelle/HOL Tutorial
  • Now out in paperback: Term Rewriting and All That
  • Publications
  • Isabelle
  • Diplomarbeit/SEP der Woche ...
  • Ein IDP!
  • Research Interests
    • Automatic and interactive theorem proving
    • Formal verification
    • Formalizing programming languages
    • Formal foundations of Java
    • Type systems
    • Semantics
    • Rewriting and unification
    • Lambda-calculus
    Projects
    Current
      Verisoft - Verified Software
      TYPES - Mathematical modelling and reasoning using typed logics. ESPRIT Working Group.
    Past
      GKLI - PhD programme Logic in Informatics
      InopSys - Calculi for system modelling
      VerifiCard - Theorem proving for JavaCard
      Isar - Intelligible semi-automated reasoning
      Bali - Formalizing Java in Isabelle
      CCL - Construction of Computational Logics. ESPRIT Working Group.
  • 79. Zhenyu Qian
    Universit¤t Bremen Java security, extensions, and semantics; object-oriented, functional, concurrent, logic programming languages; specification languages; compiler construction; program specification, construction and transformation; object-oriented analysis and design; types; lambda-calculus; unification; algebraic semantics; and theorem proving systems.
    http://www.informatik.uni-bremen.de/~qian/qian.html
    Zhenyu Qian

    Research Interests
      Java security, Java extensions, Java semantics, object-oriented, functional, concurrent, logic programming languages, specification languages, compiler construction, program specification, program construction, program transformation, object-oriented analyse and design, types, lambda-calculus, unification, algebraic semantics, theorem proving systems.
    I am now working at the Kestrel Institute . Click here to go to my new homepage. Zhenyu Qian, last update June 23, 2000

    80. MainFrame: The Lambda-calculus, Combinatory Logic, And Type Systems
    The connections between the lambdacalculus and programming languages are diverse and pervasive. Type systems are an important aspect of programming
    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.

    81. Simone Martini
    University of Bologna, Italy Type systems for programming languages, logic in computer science, lambda-calculus.
    http://www.cs.unibo.it/~martini/
    home contact teaching publications ... Dipartimento di Scienze dell'Informazione Simone Martini Simone Martini Professor of Computer Science Simone Martini received the Laurea degree in Scienze dell'Informazione and the Dottorato di Ricerca in Informatica (Ph.D. in Computer Science) from He has been a visting scientist at the Systems Research Center of Digital Equipment Corporation, Palo Alto; at Stanford University ; at , Paris; at ; and at University of California at Santa Cruz He is a member of the Executive Boards of the European Association for Computer Science Logic ( EACSL ) and of the Associazione Italiana di Logica e Applicazioni ( AILA His research interests are in the logical foundations of programming languages. He has written papers in lambda-calculus, type theory, linear and resource logics. His is 3.

    82. J Roger Hindley
    University of Wales, Swansea lambda-calculus, combinatory logic and type-theory.
    http://www-maths.swan.ac.uk/staff/jrh/
    Swansea University Physical Sciences Mathematics Department Contact
    J Roger Hindley
    Text Only Swansea University Physical Sciences ... Contact 16 October 2007 Webmaster

    83. JAR Security Kernel
    A Security Kernel Based on the lambdacalculus. The dissertation (MIT 1995) consisted of a 50-page main part (written last) consisting of 4 chapters,
    http://mumble.net/~jar/pubs/secureos/
    A Security Kernel Based on the Lambda-Calculus
    The dissertation (MIT 1995) consisted of a 50-page main part (written last) consisting of 4 chapters, followed by 80 pages of appendices, all of which had been published previously as papers or memos:
    • A. A Tractable Scheme Implementation
    • B. Program Mobile Robots in Scheme
    • C. Scheme 48 Module System [see the Scheme 48 manual
    • D. Macros That Work
    • E. Scheme 48 User's Guide [see the Scheme 48 manual
    • F. Object-Oriented Programming in Scheme
    Here are versions of the main body: I think I used the term "authentication" incorrectly in this paper.
    What the critics say
    Related sites
    • Norman Hardy's site on operating system security (with references to Joule, KeyKos, etc.). E - a scripting language and wire protocol for distributed capabilities. Very active site and mailing list (as of early 2004) with tons of introductory material and analysis.

    84. Theory Lambda (Isabelle2005: October 2005)
    Theory lambda. Up to index of Isabelle/HOL/lambda. theory lambda Basic definitions of lambdacalculus *} theory lambda imports Main begin subsection
    http://isabelle.in.tum.de/library/HOL/Lambda/Lambda.html
    Theory Lambda
    Up to index of Isabelle/HOL/Lambda theory Lambda
    imports Main
    begin
    t[s/i]" apply (erule rtrancl.induct) apply (rule rtrancl_refl) apply (erule rtrancl_trans) apply (erule subst_preserves_beta2) done end
    Lambda-terms in de Bruijn notation and substitution
    Beta-reduction
    lemmas Var i t P r s t r t s = Abs t P P s t u s u s t s = Abs s P t s t u t t P t t t u s t P P
    Congruence rules
    lemma s s' s s' lemma s s' s t s' t lemma t t' s t s t' lemma s s' t t' s t s' t'
    Substitution-lemmas
    lemma Var k u k u lemma i j j u i ] = Var ( j lemma j i j u i ] = Var j lemma i k t i ) (Suc k ) = lift (lift t k i lemma i j s j i t s j i = lift t i + 1)[lift s i j lemma i j s i j t s j i = lift t i [lift s i j lemma k s . lift t k s k t lemma i j t [lift v i /Suc j u v j i t u i v j
    Equivalence proof for optimized substitution
    lemma k . liftn t k t lemma k . liftn (Suc n t k = lift (liftn n t k k lemma n . substn t s n t [liftn n s n theorem substn t s t s
    Preservation theorems
    theorem r s r t i s t i theorem r s r t i s t i theorem r s r i s i theorem r s r i s i theorem r s t r i t s i theorem r s t r i t s i

    85. INRIA :: [inria-00090434, Version 2] A Concurrent Lambda Calculus With Futures
    lambda(fut) is a minimalist extension of the callby-value lambda-calculus that is sufficiently expressive to define and combine a variety of standard
    http://hal.inria.fr/inria-00090434/en

    86. Lambda-calculus
    The pure lambdacalculus contains no constants - neither numbers nor mathematical functions such as plus - and is untyped. It consists only of lambda
    http://burks.brighton.ac.uk/burks/foldoc/74/64.htm
    The Free Online Dictionary of Computing ( http://foldoc.doc.ic.ac.uk/ dbh@doc.ic.ac.uk Previous: LAMBDA Next: Lambda-Prolog
    lambda-calculus
    mathematics Alonzo Church in the late 1930s and early 1940s, dealing with the application of functions to their arguments. The pure lambda-calculus contains no constants - neither numbers nor mathematical functions such as plus - and is untyped. It consists only of lambda abstraction s (functions), variables and applications of one function to another. All entities must therefore be represented as functions. For example, the natural number N can be represented as the function which applies its first argument to its second N times ( Church integer N). Church invented lambda-calculus in order to set up a foundational project restricting mathematics to quantities with "effective procedures". Unfortunately, the resulting system admits Russell's paradox in a particularly nasty way; Church couldn't see any way to get rid of it, and gave the project up. Most functional programming languages are equivalent to lambda-calculus extended with constants and types.

    87. Project-Moscova:Labeled Lambda-Calculus And Variants
    New Results Labeled lambda-calculus and Variants.
    http://ralyx.inria.fr/2006/Raweb/moscova/uid41.html
    Team Moscova Members Overall Objectives Scientific Foundations Application Domains Software New Results Other Grants and Activities Dissemination Bibliography Inria ...
    Project: Moscova
    Project : moscova
    Section: New Results
    Labeled Lambda-Calculus and Variants
    Participants Tomasz Blanc Jean-Jacques Lévy Luc Maranget We introduced a new property of the labeled lambda-calculus: context irreversibility . We have if and only if . This property shows that when a (labeled) context disappears at one point of a reduction, this disappearance is irreversible: the context cannot be rebuilt in the reduction that follows. In the (unlabeled) lambda-calculus, this property is false: we have

    88. Lambda-Calculus And Computer Science Theory 1975
    Corrado Böhm (Ed.) lambdacalculus and Computer Science Theory, Proceedings of the Symposium Held in Rome, March 25-27, 1975.
    http://www.informatik.uni-trier.de/~ley/db/conf/lambda/lambda1975.html
    Lambda-Calculus and Computer Science Theory 1975: Rome, Italy
    (Ed.): Lambda-Calculus and Computer Science Theory, Proceedings of the Symposium Held in Rome, March 25-27, 1975. Lecture Notes in Computer Science 37 Springer 1975, ISBN 3-540-07416-3 BibTeX DBLP

    89. Linear Logic And Typed Lambda-Calculus Workshop
    This workshop is sponsored by the Keio University of Tokyo, the CIRM and the European Union ( Typed lambdacalculus Human Capital and Mobility project).
    http://iml.univ-mrs.fr/~ehrhard/ll-hcm-1998.html
    Linear Logic and Typed Lambda-Calculus Workshop
    Marseille-Luminy, 6-10 April 1998
    The workshop will be held at the CIRM from April the 6th to April the 10th, and will be divided in two parts:
    • The "Linear Logic Workshop", which will begin on Monday 4/6/98 morning and end on Wednesday 4/8/98 evening.
      This workshop is sponsored by the Keio University of Tokyo, the CIRM and the European Union ("Typed Lambda-Calculus" Human Capital and Mobility project).
      The program of this Workshop can be found here dvi ps
    • The "Typed Lambda-Calculus Workshop", which is the last meeting of the "Typed Lambda-Calculus" Human Capital and Mobility project. This meeting will begin on Thursday 4/9/98 morning and end on Friday 4/10/98 evening. It is sponsored by the HCM project and by the CIRM.
      The program of this Workshop can be found here dvi ps

    90. A Parigot-style Linear $\lambda$-calculus For Full Intuitionistic Linear Logic
    Keywords linear logic, $\lambda\mu$calculus, Curry-Howard isomorphism. 2000 MSC 03B20. Theory and Applications of Categories, Vol. 17, 2006, No.
    http://www.tac.mta.ca/tac/volumes/17/3/17-03abs.html
    Valeria de Paiva and Eike Ritter This paper describes a natural deduction formulation for Full Intuitionistic Linear Logic (FILL), an intriguing variation of multiplicative linear logic, due to Hyland and de Paiva. The system FILL resembles intuitionistic logic, in that all its connectives are independent, but resembles classical logic in that its sequent-calculus formulation has intrinsic multiple conclusions. From the intrinsic multiple conclusions comes the inspiration to modify Parigot's natural deduction systems for classical logic, to produce a natural deduction formulation and a term assignment system for FILL. 2000 MSC: 03B20 Theory and Applications of Categories, Vol. 17, 2006, No. 3, pp 30-48.
    http://www.tac.mta.ca/tac/volumes/17/3/17-03.dvi

    http://www.tac.mta.ca/tac/volumes/17/3/17-03.ps

    http://www.tac.mta.ca/tac/volumes/17/3/17-03.pdf

    ftp://ftp.tac.mta.ca/pub/tac/html/volumes/17/3/17-03.dvi
    ...
    TAC Home

    91. Polymorphic Lambda-calculus From FOLDOC
    (Or second order typed lambdacalculus ). An extension of typed lambda-calculus allowing functions which take types as parameters.
    http://lgxserver.uniba.it/lei/foldop/foldoc.cgi?polymorphic lambda-calculus

    Page 1     1-95 of 95    1