λ演算

在數學和計算機科學中，「可計算的」函式是基礎觀念。對於所謂的可計算性，λ-演算提供了一個簡單明確的語義，使計算的性質可以被形式化研究。λ-演算結合了兩種簡化方式，使得這個語義變得簡單。第一種簡化是不給予函式一個確定名稱，而“匿名”地對待它們。例如，兩數的平方和函式

${\displaystyle \operatorname {square\_sum} (x,y)=x^{2}+y^{2}}$

可以用匿名的形式重新寫為：

${\displaystyle (x,y)\mapsto x^{2}+y^{2}}$（理解成一包含x和y的數組被映射到${\textstyle x^{2}+y^{2}}$）

同樣地，

${\displaystyle \operatorname {id} (x)=x}$

可以用匿名的形式重新寫為：

${\displaystyle x\mapsto x}$（即輸入是直接對應到它本身。）

第二個簡化是λ演算只使用單一個參數輸入的函數。如果普通函數需要兩個參數，例如${\textstyle \operatorname {square\_sum} }$函數，可轉成接受單一參數，傳給另一個函數中介，而中介函數也只接受一個參數，最後輸出結果。例如，

${\displaystyle (x,y)\mapsto x^{2}+y^{2}}$

可以重新寫成：

${\displaystyle x\mapsto (y\mapsto x^{2}+y^{2})}$

這是稱為柯里化的方法，將多參數的函數轉換成為多個中介函數的複合鏈，每個中介函數都只接受一個參數。 將${\textstyle \operatorname {square\_sum} }$函數應用於參數(5,2)，直接產生結果

${\textstyle ((x,y)\mapsto x^{2}+y^{2})(5,2)}$

${\textstyle =5^{2}+2^{2}}$

${\textstyle =29}$,

而對於柯里化轉換版的評估，需要再多一步：

${\textstyle {\Bigl (}{\bigl (}x\mapsto (y\mapsto x^{2}+y^{2}){\bigr )}(5){\Bigr )}(2)}$

${\textstyle =(y\mapsto 5^{2}+y^{2})(2)}$ //在內層表達式中${\displaystyle x}$的定義為${\displaystyle 5}$，這就像β-歸約一樣。

${\textstyle =5^{2}+2^{2}}$ //${\displaystyle y}$的定義為${\displaystyle 2}$，再次如同β-歸約。

${\textstyle =29}$

得出相同結果。

lambda演算是由特定形式語法所組成的一種語言，一組轉換規則可操作其中的lambda項。這些轉換規則被看作是一個等式理論或者一個操作定義。如上節所述，lambda演算中的所有函數都是匿名的，它們沒有名稱，它們只接受一個輸入變量，柯里化用於實現有多個輸入變量的函數。

lambda演算的語法將一些表達式定義為有效的lambda演算式，而某一些表達式無效，就像C編程語言中有些字串有效，有些則不是。有效的lambda演算式稱為“lambda項”。

以下三個規則給出了語法上有效的lambda項，如何建構的歸納定義：

• 變量${\displaystyle x}$本身就是一個有效的lambda項
• 如果${\displaystyle t}$是一個lambda項，而${\displaystyle x}$是一個變量，則${\displaystyle (\lambda x.t)}$ 是一個lambda項（稱為lambda抽象）；
• 如果${\displaystyle t}$和${\displaystyle s}$是lambda項，那麼${\displaystyle (ts)}$是一個lambda項（稱為應用）。

其它的都不是lambda項。因此，lambda項若且唯若可重複應用這三個規則取得時，才是有效的。一些括號根據某些規則可以省略。例如，最外面的括號通常不會寫入。

“lambda抽象”是指一個匿名函數的定義，它將單一輸入的${\displaystyle \lambda x.t}$替換成${\displaystyle t}$的表達式，所以產生了一個匿名函數，它採用${\displaystyle x}$的值並返回${\displaystyle t}$。例如，${\displaystyle \lambda x.x^{2}+2}$是表示使用函數${\displaystyle f(x)=x^{2}+2}$作為${\displaystyle t}$項的一個lambda抽象。lambda抽象只是先“設置”了函數定義，還沒使用它。這個抽象在${\displaystyle t}$項中綁定了變量${\displaystyle x}$。一個應用${\displaystyle ts}$表示將函數${\displaystyle t}$應用在輸入${\displaystyle s}$，亦即對輸入${\displaystyle s}$使用函數${\displaystyle t}$產生${\displaystyle t(s)}$。

lambda演算中並沒有變量聲明的概念。如${\displaystyle \lambda x.x+y}$（即${\displaystyle f(x)=x+y}$）的定義中，lambda演算將${\displaystyle y}$當作尚未定義的變量。lambda抽象${\displaystyle \lambda x.x+y}$在語法上是有效的，並表示將其輸入添加到未知${\displaystyle y}$的函數。

可用圓括弧對來消除歧義。例如，${\displaystyle \lambda x.((\lambda x.x)x)}$和${\displaystyle (\lambda x.(\lambda x.x))x}$表示不同的項（儘管它們剛好化簡到相同值）。這裡第一個例子定義了一個包含子函數的抽象，並將子函數應用於x（先應用後傳回）的結果；而第二個例子定義了一個傳回任何輸入的函數，然後在應用過程中傳回對輸入為x的應用（返回函數然後應用）。

在lambda演算中，函數被認為是頭等物件，因此函數可以當作輸入，或作為其它函數的輸出返回。

例如，${\displaystyle \lambda x.x}$表示映射到本身的函數，${\displaystyle x\mapsto x}$和${\displaystyle (\lambda x.x)y}$表示將這個函數應用於${\displaystyle y}$。此外，${\displaystyle (\lambda x.y)}$則表示無論輸入為何，始終返回${\displaystyle y}$值的常數函數${\displaystyle x\mapsto y}$。lambda演算中的函數應用是左結合的，因此${\displaystyle stx}$表示${\displaystyle (st)x}$。

有幾個“等價”和“化簡”的概念，允許將各個lambda項“縮減”為“相同”的lambda項。

對於lambda項，等價的基本形式定義，是${\displaystyle \alpha }$-等價。它捕捉了直覺概念，在lambda抽象中一個綁定變量的特別選擇（通常）並不重要。 比如，${\displaystyle \lambda x.x}$和${\displaystyle \lambda y.y}$是${\displaystyle \alpha }$-等價的lambda項，它們都表示相同的函數（自映射函數）；但如${\displaystyle x}$和${\displaystyle y}$項則不是${\displaystyle \alpha }$-等價的，因為它們並非以lambda抽象方式綁定的。 在許多演示中，通常會確定${\displaystyle \alpha }$-等價的lambda項。

為了能夠定義${\displaystyle \beta }$-歸約，需要以下定義：

所謂的自由變量是那些在lambda抽象不受到綁定的變量。表達式中的一組自由變量定義歸納如下：

• ${\displaystyle x}$的自由變量就只是${\displaystyle x}$
• ${\displaystyle \lambda x.t}$的自由變量集合，是在${\displaystyle t}$中移除了${\displaystyle x}$的自由變量集合。
• ${\displaystyle ts}$的自由變量是${\displaystyle t}$的一組自由變量，與${\displaystyle s}$的一組自由變量，這兩項變量的並集。

例如，代表映射自身的${\displaystyle \lambda x.x}$，其中的lambda項沒有自由變量，但是在函數${\displaystyle \lambda x.yx}$中的lambda項，有一個自由變量${\displaystyle y}$。

假設${\displaystyle t}$，${\displaystyle s}$和${\displaystyle r}$是lambda項，而${\displaystyle x}$和${\displaystyle y}$是變量。如果寫成${\displaystyle t[x:=r]}$是一種避免被捕獲的記法方式，表示在${\displaystyle t}$這個lambda項中，以${\displaystyle r}$來替換${\displaystyle x}$變量的值。這定義為：

• ${\displaystyle x[x:=r]=r}$；
• ${\displaystyle y[x:=r]=y}$，如果${\displaystyle x\neq y}$；
• ${\displaystyle (ts)[x:=r]=(t[x:=r])(s[x:=r])}$；
• ${\displaystyle (\lambda x.t)[x:=r]=\lambda x.t}$；
• 如果${\displaystyle x\neq y}$而且${\displaystyle y}$不在lambda項${\displaystyle r}$的自由變量中，則${\displaystyle (\lambda y.t)[x:=r]=\lambda y.(t[x:=r])}$。對於lambda項${\displaystyle r}$，變量${\displaystyle y}$被稱為是“新鮮”的。

例如，${\displaystyle (\lambda x.x)[y:=y]=\lambda x.(x[y:=y])=\lambda x.x}$ 和${\displaystyle ((\lambda x.y)x)[x:=y]=((\lambda x.y)[x:=y])(x[x:=y])=(\lambda x.y)y}$。

新鮮度條件（要求${\displaystyle y}$不在lambda項${\displaystyle r}$中的自由變量中）對於確保替換不會改變函數的意義很重要。例如，忽視新鮮度條件的替代：${\displaystyle (\lambda x.y)[y:=x]=\lambda x.(y[y:=x])=\lambda x.x}$。此替換會將原本意義為常量函數的${\displaystyle \lambda x.y}$，轉換成意義為映射自身函數的${\displaystyle \lambda x.x}$。

一般來說，在無法滿足新鮮度條件的情況，可利用${\displaystyle \alpha }$-重新命名使用一個合適的新變量來補救，切換回正確的替換概念；比如在${\displaystyle (\lambda x.y)[y:=x]}$中，使用一個新變量${\displaystyle z}$重新命名這個lambda抽象，獲取${\displaystyle (\lambda z.y)[y:=x]=\lambda z.(y[y:=x])=\lambda z.x}$，則替換就能保留原本函數的義涵。

β-歸約規定了形式如${\displaystyle (\lambda x.t)s}$的應用，可以化簡成${\displaystyle t[x:=s]}$項。符號記法${\displaystyle (\lambda x.t)s\to t[x:=s]}$用於表示${\displaystyle (\lambda x.t)s}$ 經過β-歸約轉換為${\displaystyle t[x:=s]}$。例如，對於每個${\displaystyle s}$，可轉換為${\displaystyle (\lambda x.x)s\to x[x:=s]=s}$。這表明${\displaystyle \lambda x.x}$實際上的應用是映射自身函數。同樣地，${\displaystyle (\lambda x.y)s\to y[x:=s]=y}$，表明了${\displaystyle \lambda x.y}$是一個常量函數。

lambda演算可視為函數式編程語言的理想化版本，如Haskell或ML語言。在這種觀點下，β-歸約對應於一組計算步驟。 這個步驟重複應用β-轉換，一直到沒有東西能再被化簡。在無型別lambda演算中，如本文所述，這個歸約過程可能無法終止， 比如${\displaystyle \Omega =(\lambda x.xx)(\lambda x.xx)}$，是個特殊的lambda項。這裡 ${\displaystyle (\lambda x.xx)(\lambda x.xx)\to (xx)[x:=\lambda x.xx]=(x[x:=\lambda x.xx])(x[x:=\lambda x.xx])=(\lambda x.xx)(\lambda x.xx)}$ 也就是說，該lambda項在一次β-歸約中化簡到本身，因此歸約過程將永遠不會終止。

無型別lambda演算的另一方面是它並不區分不同種類的資料。例如，需要編寫只針對數字操作的功能。然而，在無型別的lambda演算中，沒有辦法避免函數被應用於真值、字串或其它非數字物件。

Alpha-变换规则表达的是，被绑定变量的名称是不重要的。比如说λx.x和λy.y是同一个函数。尽管如此，这条规则并非像它看起来这么简单，关于被绑定的变量能否由另一个替换有一系列的限制。

Alpha-变换规则陈述的是，若V与W均为变量，E是一个lambda表达式，同时E[V:=W]是指把表达式E中的所有的V的自由出现都替换为W，那么在W不是 E中的一个自由出现，且如果W替换了V，W不会被E中的λ绑定的情况下，有

λV.E == λW.E[V:=W]

这条规则告诉我们，例如λx.(λx.x) x这样的表达式和λy.(λx.x) y是一样的。

Beta-归约规则表达的是函数作用的概念。它陈述了若所有的E'的自由出现在E [V:=E']中仍然是自由的情况下，有

((λV.E) E') == E [V:=E']

成立。

==关系被定义为满足上述两条规则的最小等价关系（即在这个等价关系中减去任何一个映射，它将不再是一个等价关系）。

对上述等价关系的一个更具操作性的定义可以这样获得：只允许从左至右来应用规则。不允许任何beta归约的lambda表达式被称为Beta范式。并非所有的lambda表达式都存在与之等价的范式，若存在，则对于相同的形式参数命名而言是唯一的。此外，有一个算法用户计算范式，不断地把最左边的形式参数替换为实际参数，直到无法再作任何可能的规约为止。这个算法当且仅当lambda表达式存在一个范式时才会停止。Church-Rosser定理说明了，当且仅当两个表达式等价时，它们会在形式参数换名后得到同一个范式。

前两条规则之后，还可以加入第三条规则，eta-变换，来形成一个新的等价关系。Eta-变换表达的是外延性的概念，在这里外延性指的是，对于任一給定的参数，当且仅当两个函数得到的结果都一致，則它们將被視同為一个函数。Eta-变换可以令 ${\displaystyle \lambda x.fx}$ 和 ${\displaystyle f}$ 相互转换，只要 ${\displaystyle x}$ 不是 ${\displaystyle f}$ 中的自由變量。下面说明了为何这条规则和外延性是等价的：

若 ${\displaystyle f}$ 与 ${\displaystyle g}$ 外延地等价，即，${\displaystyle fa==ga}$ 对所有的 ${\displaystyle \lambda }$ 表达式 ${\displaystyle a}$成立，则当取 ${\displaystyle a}$ 为在 ${\displaystyle f}$ 中不是自由出现的变量 ${\displaystyle x}$时，我们有${\displaystyle f(x)==g(x)}$，因此 ${\displaystyle \lambda x.fx==\lambda x.gx}$，由eta-变换f == g。所以只要eta-变换是有效的，会得到外延性也是有效的。

相反地，若外延性是有效的，则由beta-归约，对所有的y有(λx .f x) y == f y，可得λx .f x == f，即eta-变换也是有效的。

在lambda演算中有许多方式都可以定义自然数，但最常见的还是邱奇数，下面是它们的定义：

0 = λf.λx.x
1 = λf.λx.f x
2 = λf.λx.f (f x)
3 = λf.λx.f (f (f x))

以此类推。直观地说，lambda演算中的数字n就是一个把函数f作为参数并以f的n次幂为返回值的函数。换句话说，邱奇整数是一个高阶函数 -- 以单一参数函数f为参数，返回另一个单一参数的函数。

(注意在邱奇原来的lambda演算中，lambda表达式的形式参数在函数体中至少出现一次，这使得我们无法像上面那样定义0)在邱奇整数定义的基础上，我们可以定义一个后继函数，它以n为参数，返回n + 1：

SUCC = λn.λf.λx.f(n f x)

加法是这样定义的：

PLUS = λm.λn.λf.λx.m f (n f x)

PLUS可以被看作以两个自然数为参数的函数，它返回的也是一个自然数。你可以试试验证

PLUS 2 3 

与5是否等价。乘法可以这样定义：

MULT = λm.λn.m (PLUS n) 0,

即m乘以n等于在零的基础上m次加n。另一种方式是

MULT = λm.λn.λf.m (n f)

正整数n的前驱元（predecessesor）PRED n = n - 1要复杂一些：

PRED = λn.λf.λx.n (λg.λh.h (g f)) (λu.x) (λu.u)

或者

PRED = λn.n(λg.λk.(g 1) (λu.PLUS(g k) 1) k) (λl.0) 0

注意(g 1)(λu.PLUS(g k) 1) k表示的是，当g(1)是零时，表达式的值是k，否则是g(k)+ 1。

习惯上，下述两个定义（称为邱奇布尔值）被用作TRUE和FALSE这样的布尔值：

TRUE := λx.λy.x

FALSE := λx.λy.y

(注意FALSE等价于前面定义邱奇数零)

接着，通过这两个λ-项，我们可以定义一些逻辑运算：

AND := λp q.p q FALSE

OR := λp q.p TRUE q

NOT := λp.p FALSE TRUE

IFTHENELSE := λp x y.p x y

我们现在可以计算一些逻辑函数，比如：

AND TRUE FALSE

≡(λp q.p q FALSE) TRUE FALSE →_β TRUE FALSE FALSE

≡(λx y.x) FALSE FALSE →_β FALSE

我们见到AND TRUE FALSE等价于FALSE。

“谓词”是指返回布尔值的函数。最基本的一个谓词是ISZERO，当且仅当其参数为零时返回真，否则返回假：

ISZERO := λn.n (λx.FALSE) TRUE

运用谓词与上述TRUE和FALSE的定义，使得"if-then-else"这类语句很容易用lambda演算写出。

有序对（2-元组）数据类型可以用TRUE、FALSE和IF来定义。

CONS := λx y.λp.IF p x y

CAR := λx.x TRUE

CDR := λx.x FALSE

链表数据类型可以定义为，要么是为空列表保留的值（e.g.FALSE），要么是CONS一个元素和一个更小的列表。

在lambda演算中，函式庫將採用預先定義好的函數集合，其中lambda項僅僅是特定的常量。純粹的lambda演算法並不具有命名常數的概念，因為所有的原子λ項都是變量；但是在程序主體中，我們可將一個變量當成常量的名稱，利用lambda抽象把這個變量綁定，並將該lambda抽象應用於預期的定義，來模擬命名常量的作法。因此在N（“主程序”的另一個lambda項）中，要以f來表示M（一些明確的lambda項），則寫成如下：

(λf.N) M

作者經常引入類似如let的语法糖，允許以更直觀的次序撰寫上述內容：

let f = M in N

通過等號鏈接這個命名常數，即可將lambda演算“編程”的一個lambda項，寫為零或多個函數的定義，而使用構成程序主體的那些函數。這個let顯著的限制，是在M中並沒有定義f名稱，因為M不在綁定f的lambda抽象範疇之內；這意味著遞歸函數定義不能以let來使用M。更進步的letrec語法糖允許以直覺的方式編寫遞歸函數定義，而不需用到不動點組合子。

递归是使用函数自身的函数定义；在表面上，lambda演算不允许这样。但是这种印象是误解。考虑个例子，阶乘函数f(n)递归的定义为

f(n):= if n = 0 then 1 else n·f(n-1)。

在lambda演算中，你不能定义包含自身的函数。要避免这样，你可以开始于定义一个函数，这里叫g，它接受一个函数f作为参数并返回接受n作为参数的另一个函数：

g := λf n.(if n = 0 then 1 else n·f(n-1))。

函数g返回要么常量1，要么函数f对n-1的n次应用。使用ISZERO谓词，和上面描述的布尔和代数定义，函数g可以用lambda演算来定义。

但是，g自身仍然不是递归的；为了使用g来建立递归函数，作为参数传递给g的f函数必须有特殊的性质。也就是说，作为参数传递的f函数必须展开为调用带有一个参数的函数g -- 并且这个参数必须再次f函数!

换句话说，f必须展开为g(f)。这个到g的调用将接着展开为上面的阶乘函数并计算下至另一层递归。在这个展开中函数f将再次出现，并将被再次展开为g(f)并继续递归。这种函数，这裡的f = g(f)，叫做g的不动点，并且它可以在lambda演算中使用叫做悖论算子或不动点算子来实现，它被表示为Y -- Y组合子：

Y = λg.(λx.g(x x))(λx.g(x x))

在lambda演算中，Y g是g的不动点，因为它展开为g(Y g)。现在，要完成我们对阶乘函数的递归调用，我们可以简单的调用 g(Y g)n，这裡的n是我们要计算它的阶乘的数。

比如假定n = 5，它展开为：

(λn.(if n = 0 then 1 else n·((Y g)(n-1)))) 5

if 5 = 0 then 1 else 5·(g(Y g，5-1))

5·(g(Y g)4)

5·(λn.(if n = 0 then 1 else n·((Y g)(n-1))) 4)

5·(if 4 = 0 then 1 else 4·(g(Y g，4-1)))

5·(4·(g(Y g)3))

5·(4·(λn.(if n = 0 then 1 else n·((Y g)(n-1))) 3))

5·(4·(if 3 = 0 then 1 else 3·(g(Y g，3-1))))

5·(4·(3·(g(Y g)2)))

...

等等，递归的求值算法的结构。所有递归定义的函数都可以看作某个其他适当的函数的不动点，因此，使用Y所有递归定义的函数都可以表达为lambda表达式。特别是，我们现在可以明晰的递归定义自然数的减法、乘法和比较谓词。

某一些lambda項有普遍接受的名稱：

I := λx.x

K := λx.λy.x

S := λx.λy.λz.x z (y z)

B := λx.λy.λz.x (y z)

C := λx.λy.λz.x z y

W := λx.λy.x y y

U := λx.λy.y (x x y)

ω := λx.x x

Ω := ω ω

Y := λg.(λx.g (x x)) (λx.g (x x))

其中有幾個在“消除lambda抽象”中有直接的應用，將lambda項變為組合演算的術語。

如果N是一個沒有λ-抽象的lambda項，但可能包含了命名常量（組合子），則存在一個lambda項T(x,N)，這相同於一個缺少λ-抽象（除了作為命名常量的一部份，如果這些被認為是非原子的）的λx.N；也可以被視為匿名變量，就如同T(x,N)從N之中刪除所有出現的x，同時仍然允許在N包含x的位置替換參數值。

轉換函數T可由下式定義：

T(x, x) := I

T(x, N) := K N if x is not free in N.

T(x, M N) := S T(x, M) T(x, N)

在這兩種情況下，形式T(x,N)P可藉由使初始的組合子I，K或S獲取參數P而化簡， 就像(λx.N) P經過β-歸約一樣。I返回那個參數。K則將參數拋棄，就像(λx.N)，如果x在N中不是以自由變量出現。S將參數傳遞給應用程序的兩個子句，然後將第一個結果應用到第二個的結果之上。

組合子B和C類似於S，但把參數傳遞給應用的一個子項（B傳給“參數”子項，而C傳給“函數”子項），如果子項中沒有出現x，則保存後續的K。與B和C相比，S組合子實際上混合了兩個功能： 重新排列參數，並複製一個參數，以便它可以在兩個地方使用。W組合子只做後者，產生了SKI组合子演算的B，C，K，W系統。

比如计算平方的函数 square 在 Lisp 中可以表示为如下的 lambda 表达式

(lambda (x) (* x x))

符号 lambda 创建一个匿名函数，给定参数列表 (x) ，以及一个作为函数体的表达式 (* x x)。 匿名函数有时称为 lambda 表达式。

很多命令式语言都有函数指针或者类似的机制。但是函数指针并不是类型中的一等公民，函数是一等公民当且仅当函数可以在运行时创建。 下面一些语言支持函数的运行时创建： Smalltalk、 JavaScript、 Kotlin、 Scala、 Python3、 C# ("delegates")、 C++11等。