Lambda calculus

In mathematical logic and computer science, lambda calculus, also λ-calculus, is a formal system (a system that can be used to figure out different logical theories and ideas). It was made to explore different ways of creating and using mathematical functions, and it lays out rules for doing this. It is also a tool for exploring recursion, and it has been used to explain what a computable function is. It was made by Alonzo Church and Stephen Cole Kleene in the 1930s. In 1936, Church used lambda calculus to show that there is no solution to the Entscheidungsproblem.^[1]^[2]

Lambda calculus can be called the smallest universal programming language. At its core, lambda calculus is made up of just one transformation rule (something called variable substitution) and just one way to define a function. Each function definition has a list of the function's parameters, which are all of the variables that can be used in that function. Variable substitution is where specific variables in a function are replaced by other values (for example, the value $2$ could take the place of every spot in a function where the variable $x$ appears). This is called a transformation rule because it can be used to transform lambda expressions by changing around their values.

Lambda calculus is considered "universal" because it can be used to both create and find the answer to any computable function. This is exactly what a Turing machine can do, so lambda calculus and Turing machines are said to be equivalent. However, lambda calculus focuses more on the use of transformation rules. It does not care about the actual machine that puts those rules into place. It is an approach more related to software than to hardware.

There is no way to answer the question of whether two lambda calculus expressions are the same as each other (in more specific words, there is no general algorithm that can show that two lambda expressions are equivalent). This was the first problem where the idea of undecidability could be proven. Later, undecidability was also proven for the halting problem, where it was shown that there is no general way to show whether or not a program will keep running forever. Lambda calculus has had large effects on lots of functional programming languages, such as LISP, ML, and Haskell.

Syntax

Lambda calculus has simple syntax (rules). Every program is made of lambda terms which are as follows:

Any symbol or word ( $x$ , $y$ , $foo$ , or anything else) is called a variable.
Abstractions are always in the form of $\lambda x.M$ with $\lambda$ indicating the start of an abstraction, $x$ being any variable, and $M$ being the function definition (like $\lambda x.x+2$ would take in $x$ and return $x+2$ .)
An application is actually setting $x$ (the variable) to equal something, in the form $\lambda x.MN$ ( $N$ is input). an example would be $\lambda x.x+2$ $5$ , with $\lambda x.x+2$ being the function, $5$ being the input and $\lambda x.x+2$ $5$ being the abstraction.

For the application and abstraction examples, $x+2$ and $5$ were used. This is not valid lambda calculus, as the only valid syntax are the lambda terms shown above. There are ways to emulate addition, numerals, strings (words), and any other mathematical concept in lambda calculus.^[3]

Reduction and Conversion

There are three types of reduction: α-conversion, β-reduction, and η-conversion.

α-conversion states that $\lambda x.x$ is exactly the same as $\lambda y.y$ , as long as they are separate. Variable names are only to distinguish between functions and/or inputs.
β-reduction states that $\lambda x.x+2$ $5$ ( $\lambda x.x+2$ as the function, $5$ as the input) and $5+2$ are the same. You destroy the $\lambda x$ , (leaving only $x+2$ ) and replace all instances of $x$ with $5$ . this results in $5+2$ , which simplifies to $7$ . This is the most important one, and is the basis of lambda calculus.
η-conversion states that $\lambda x.\lambda y.y$ is not needed, and that it converts to $\lambda y.y$ . However, $\lambda x.\lambda y.x$ , cannot be η-converted. This is because $\lambda y.x$ outputs $x$ , and this means that the $\lambda x$ at the beginning is necessary; β-reduction should be used if you can use it. This is the least common type and can be ignored most of the time.

You perform each type or reduction if you can. Once it can no longer be simplified, the program has halted (stopped).

Common mistakes

$\lambda x.y\nRightarrow \lambda z.z$ this is incorrect because $\lambda x$ is using the variable $y$ . If it was $\lambda x.x$ , conversion could be done.

$((\lambda x.\lambda y.(x\ y)\ \ FUNCTION)\ 5)\nRightarrow FUNCTION$ it should equal $FUNCTION\ 5$ .

$\lambda x.\lambda y.x\nRightarrow \lambda y.x$ you cannot get rid of the $\lambda x$ . This is because

Encoding and Datatypes

Because of the limited syntax, it may seem impossible to make numbers or strings or anything else that many programming languages have, but it's a matter of encoding. Lambda calculus compensates for this by using the methods demonstrated in the sections below.

Church numerals

Church numerals use the following encoding standards (rules):^[4]^[5]

$0=\lambda f.\lambda x.x$ $1=\lambda f.\lambda x.f\ x$ $2=\lambda f.\lambda x.f\ (f\ x)$ $3=\lambda f.\lambda x.f\ (f\ (f\ x))$ $n=\lambda f.\lambda x.\underbrace {f\ (f\ (\cdots (f\ x)} _{n}$ Note: Church numerals are made for whole numbers. There are other standards for encoding for all rational numbers.

Because of the syntax of lambda calculus, numbers are also functions, and can take in inputs; all functions can output another function as a result. Numeral n applies x to f, n-times. This allows you to repeat a function n times. Repetition is the core of performing arithmetic on numbers in lambda calculus.

In order to increment a number n, you can use the "successor" function, which allows you to get the next natural number.

$SUCC=\lambda n.\lambda f.\lambda x\ f\ (n\ f\ x)$

This function repeats f $n$ times, applies that to x, then applies f again. In other words, it repeats f $n+1$ times.

By repeating the successor function, addition can be achieved. Adding x to y really just means incrementing y x times in a row.

We define the plus function as

$PLUS=\lambda m.\lambda n.m\ SUCC\ n$

This function simply repeats the successor function m times, then applies that function to n. We can verify that, for example, $PLUS23$ reduces to the same expression as $5$ . It's typically written like this

$PLUS=\lambda m.\lambda n.\lambda f.\lambda x.m\ f\ (n\ f\ x)$

And we can continue like this, multiplication is simply repeated addition, and exponentiation is simply repeated multiplication.

$MULT=\lambda m.\lambda n.m\ PLUS\ n$ $POW=\lambda m.\lambda n.m\ MULT\ n$ Note: Remember that these are not normal operators, but functions. $m\ PLUS\ n$ does not mean $m+n$ , it means a function repeatedly applying $PLUS$ to $m$ $n$ times in a row.

Booleans and Logic Gates

Booleans can be thought of as a lightbulb: they can be on or off (true or false). Typically, you use church booleans for representing these.^[5]

$\lambda x.\lambda y.x$ (a function that takes in two values and returns the first one) for true.
$\lambda x.\lambda y.y$ (a function that takes in two values and returns the second one) for false.^[5]

From these, you can make logic gates and conditionals.

The AND logic gate takes in two inputs and returns true if both of them are true. It is defined as

$AND=\lambda p.\lambda q.p\ q\ p$

The other gates — OR, XOR, and NOT — are below.

$OR=\lambda p.\lambda q.p\ (p\ q)$

$NOT=\lambda p.p\ (FALSE\ \ TRUE)$

$XOR=\lambda p.\lambda q.p\ (NOT\ q)\ q$

NAND, NOR, and XNOR can be made by combining these gates.

Pairs

A pair is a way of storing two things together. You can put anything in a pair, including Church numerals, booleans, and other pairs.

A pair looks like this: ${\textstyle \lambda f.fxy}$ , where x and y are the two things in the pair. Pairs are also functions that take in a function and apply it to both things in the pair.^[2]