{
  "id": "lambda-calculus",
  "title": "λ演算",
  "lang": "zh-Hans",
  "source_lang": "en",
  "summary": "λ演算是以函数和代换为核心的形式系统，为可计算性、函数式编程及程序与证明之间的联系奠定基础。",
  "category": "computer-science",
  "subcategory": "algorithms-theory",
  "type": "concept",
  "aliases": [
    "Lambda演算",
    "兰姆达演算"
  ],
  "generated_at": "2026-11-03",
  "model": "pro/gpt-6.1-sol",
  "url": "https://aiwiki.page/zh/lambda-calculus/",
  "translations": {
    "en": {
      "url": "https://aiwiki.page/en/lambda-calculus/",
      "json": "https://aiwiki.page/en/lambda-calculus.json"
    }
  },
  "sections": [
    {
      "heading": "",
      "text": "λ演算是一种形式语言，也是一套通过函数表达计算的变换规则系统。它的基本表达式描述变量、函数定义和函数应用；计算主要通过用实参替换函数的形参来进行。尽管基本构造如此精简，无类型λ演算仍能表达所有可有效计算的函数。因此，它与图灵机并列，是计算机科学中的基础模型，也是函数式编程的数学基础。\n\nλ演算由阿隆佐·丘奇于20世纪30年代提出，最初是他为数学与逻辑奠定基础的一项尝试的组成部分。此后的发展确立了关于可计算性、等式推理的一致性以及求值策略行为的若干核心结果。带类型的λ演算还将计算与数学证明联系起来：函数类型对应于蕴涵，程序则可以充当证明。\n\n“λ演算”指的是一族相互关联的系统，而非某一种编程语言。无类型λ演算允许不受限制的函数应用，也允许不终止的计算。带类型的演算则施加各种约束，以保证计算终止、组织抽象或支持证明。实际的编程语言和证明系统借鉴了这些思想，并在此基础上加入基本演算所不具备的数据类型、效应、模块和实现机制。"
    },
    {
      "heading": "历史发展与数学背景",
      "text": "丘奇在1932年和1933年发表的论文中引入了λ记法，作为其提出的一套数学基础体系的一部分。这种记法允许直接用表达式表示函数，而不必另行给函数命名。例如，\\(\\lambda x.M\\) 表示一个参数为 \\(x\\)、函数体为 \\(M\\) 的函数。这明确区分了两个基本概念：含有某个变量的表达式，以及对该变量进行抽象后得到的函数。\n\n最初的基础体系比当今通常研究的λ演算更为宏大。斯蒂芬·克莱尼和J. B. 罗瑟于1935年证明，丘奇最初的逻辑系统是不一致的。但这并不意味着其底层的函数演算无法使用：λ项的变换规则可以与那些存在问题的逻辑原则分离开来。计算演算与用于证明命题的逻辑之间的区别，在后来的发展中变得十分重要。\n\n1936年，丘奇利用λ可定义性，对有效计算给出了精确的刻画，并证明了判定问题（Entscheidungsproblem），即一阶逻辑有效性的判定问题，是不可判定的。艾伦·图灵也于1936年独立提出了他的计算机器模型，随后证明了该模型与λ可定义性的等价性。克莱尼的工作则将这些方法与递归函数联系起来。这些不同途径最终殊途同归，构成了丘奇—图灵论题的基础：任何可有效计算的函数，都可以在这些等价的形式模型中的任意一种上计算。这是关于有效计算这一非形式概念的论题，而不是仅从某个形式系统中推导出的定理。\n\n同样在1936年，丘奇和罗瑟证明了如今以他们的名字命名的合流性结果。它表明，在纯λ演算中，选择不同的归约步骤不会得到彼此不相容的最终结果。丘奇1941年的专著《λ变换演算》系统整理了这一领域的记法和数学处理方法。由摩西·申芬克尔和哈斯凯尔·柯里发展起来的组合逻辑中的相关工作表明，可以消去约束变量，转而使用一小组基本算子。\n\n从20世纪50年代末开始，λ演算在编程语言设计中的地位日益重要。约翰·麦卡锡在Lisp编程语言中采用了λ记法，不过早期Lisp的绑定行为与数学上的λ演算并不完全相同。彼得·兰丁在20世纪60年代的工作，尤为明确地揭示了编程语言与基于λ演算的抽象机之间的联系。此后，类型论、语义学和证明助手的发展，使λ演算从数值计算的模型扩展为一个可用于推究语言设计和数学证明的框架。"
    },
    {
      "heading": "项、绑定与替换",
      "text": "纯无类型λ演算有三种项。给定一个可数无穷的变量名集合，其语法为\n\n\\[M,N ::= x \\mid (\\lambda x.M) \\mid (M\\,N).\\]\n\n变量是项；抽象 \\(\\lambda x.M\\) 是项；将一个项应用于另一个项，得到的仍是项。这里没有内置的整数、布尔值、赋值或循环。这些功能可以通过编码实现，也可以作为扩展引入。应用按左结合解析，因此 \\(M\\,N\\,P\\) 表示 \\((M\\,N)\\,P\\)。抽象的主体向右延伸，直至外围语法所允许的最远位置，因此 \\(\\lambda x.M\\,N\\) 表示 \\(\\lambda x.(M\\,N)\\)。\n\n抽象会绑定其主体中出现的形参。在 \\(\\lambda x.x\\,y\\) 中，\\(x\\) 的这次出现是绑定的，而 \\(y\\) 的这次出现是自由的。绑定关系由作用域决定，而不只是由名称的拼写决定：在 \\(\\lambda x.(x\\,(\\lambda x.x))\\) 中，最内层的 \\(x\\) 属于内层抽象。自由变量集合递归定义如下：\n\n\\[\\begin{aligned} FV(x)&=\\{x\\},\\\\ FV(M\\,N)&=FV(M)\\cup FV(N),\\\\ FV(\\lambda x.M)&=FV(M)\\setminus\\{x\\}. \\end{aligned}\\]\n\n没有自由变量的项称为闭项；否则称为开项。\n\n绑定变量的名称被认为不具有计算意义。项 \\(\\lambda x.x\\) 和 \\(\\lambda z.z\\) 表达的是同一个恒等函数。在不改变绑定关系的前提下，对绑定变量进行一致的重命名，称为 α变换。在数学处理中，λ项往往被视为这种重命名关系下的等价类，从而使结果不依赖于名称的任意选择。\n\n替换记作 \\(M[x:=N]\\)，表示将 \\(M\\) 中自由出现的 \\(x\\) 替换为 \\(N\\)。替换必须避免变量捕获：在插入项中自由出现的变量，不得意外变成绑定变量。例如，在 \\(\\lambda y.x\\) 中直接用 \\(y\\) 替换 \\(x\\)，会得到 \\(\\lambda y.y\\)，从而把常值函数变成恒等函数。正确的做法是先对绑定变量重命名：\n\n\\[(\\lambda y.x)[x:=y] = (\\lambda z.x)[x:=y] = \\lambda z.y.\\]\n\n这里选择一个未使用过的新变量 \\(z\\)，使插入的 \\(y\\) 仍然保持自由。\n\n这些看似细微的语法细节，对可靠的实现和形式化证明至关重要。编译器所做的变换如果捕获了变量，就可能改变程序的行为，即使变换后的表达式表面上看起来与原式相似。其他表示方法，包括 德布鲁因索引，不使用名称，而是用绑定变量与其绑定位置之间的距离来编码该变量。这类表示使项的相等性判断不再需要α重命名，但在执行替换时，如果项跨越了绑定边界，就必须谨慎调整数值索引。"
    },
    {
      "heading": "归约、相等与合流性",
      "text": "核心计算规则是 β归约：\n\n\\[(\\lambda x.M)\\,N \\longrightarrow_\\beta M[x:=N].\\]\n\n将一个抽象应用于一个实参所形成的表达式称为 β可约式，用替换后的函数体取代它的操作称为收缩。因此，\\((\\lambda x.x)\\,A\\) 归约为 \\(A\\)，而 \\((\\lambda x.x\\,x)\\,A\\) 归约为 \\(A\\,A\\)。后一个例子表明，一次归约可以复制一个实参。在不加限制的演算中，收缩可以发生在任何外围项的内部，包括抽象的函数体内部。\n\n如果一个项的任何位置都不含 β可约式，就称它处于 β范式。例如，\\(\\lambda x.x\\) 是范式，\\(x\\,y\\) 也是范式，尽管后者是一个应用：它的头部是变量，而不是抽象。如果至少存在一个归约序列能够到达范式，就称该项是弱规范化的。如果每个归约序列都会终止，就称该项是强规范化的。这两种性质并不相同，因为一个项可能包含不终止的子计算，而另一次归约可以将这部分计算丢弃。\n\nβ可转换性是由 β归约生成的等价关系：如果两个项可以通过有限次归约和反向归约相互连接，就称它们可转换。这种等式意义上的概念比有方向的执行过程更宽泛。证明两个项可转换，并不一定就给出了计算机求值其中任一项的合理方法。这一形式理论中的相等，还必须与数学函数的相等以及特定编程语言中的不可区分性加以区别。\n\n丘奇—罗瑟定理指出，β归约具有合流性。如果一个项 \\(M\\) 经过零步或多步归约既能得到 \\(P\\)，又能得到 \\(Q\\)，那么必定存在某个项 \\(R\\)，使得两者都能通过进一步归约到达它：\n\n\\[M\\longrightarrow_\\beta^{*}P,\\quad M\\longrightarrow_\\beta^{*}Q \\quad\\Rightarrow\\quad \\exists R\\; P\\longrightarrow_\\beta^{*}R \\ \\land\\ Q\\longrightarrow_\\beta^{*}R.\\]\n\n因此，在将 α转换视为等同的意义下，一个项至多有一个 β范式。合流性并不意味着范式一定存在，也不意味着每种求值策略都能找到范式。它的意义在于，不同的归约选择不会产生彼此不同且不相容的范式结果。\n\n另一条原则是 η转换，它表达了一种函数外延性：\n\n\\[\\lambda x.F\\,x =_\\eta F \\qquad\\text{if }x\\notin FV(F).\\]\n\n这一附加条件至关重要：该表达式必须只是将实参传给 \\(F\\)，而不能改变 \\(F\\) 所指代的对象。β与η共同构成了一套实用的函数等式理论。不过，不能不加区分地将η转换应用于带有副作用或采用严格求值的编程语言。如果对 \\(F\\) 求值会发散或执行可观察的动作，那么将 \\(F\\) 替换为一个抽象可能会推迟这一行为，从而改变程序的可观察结果。"
    },
    {
      "heading": "求值策略与终止性",
      "text": "尽管不受限制的 β 归约允许多种后续归约步骤，求值器仍需要一条规则来决定选择哪一步。正规序归约反复归约最左、最外层的可归约式。由标准化定理可知，只要 β 正规形存在，这一策略就能到达它。应用序归约通常指最左、最内层归约，它会尝试先归约参数，再应用包围这些参数的函数。即使整个项存在正规形，这种策略也可能无法终止。\n\n一个经典例子使用如下自应用项：\n\n\\[\\Omega=(\\lambda x.x\\,x)(\\lambda x.x\\,x).\\]\n\n它经 β 归约后仍是自身，因此归约可以无限进行下去。现在考虑：\n\n\\[(\\lambda x.\\lambda y.y)\\,\\Omega.\\]\n\n最外层的一步归约就会立即得到 \\(\\lambda y.y\\)，因为该函数并不使用它的参数。如果一种策略坚持先将 \\(\\Omega\\) 归约到正规形，再执行外层应用，就永远无法得到这一结果。这个例子说明，结果是否存在，与某种具体求值过程能否得到它，是两回事。\n\n编程语言的求值器通常不会进行完全正规化，而是更早停止。在按值调用中，函数的参数会先被求值为一个值，然后才进行替换或实现层面的等价操作。在基本的 lambda 语言中，抽象被视为值，求值不会继续进入其函数体内部。按名调用则将尚未求值的参数代入，只有在执行确有需要时才对其求值；如果参数被多次使用，就可能重复计算。这些弱求值策略不同于完全的应用序正规化和正规序正规化，后两者还可能在抽象内部进行归约。\n\n按需调用在非严格求值的基础上加入了共享机制。实现时不会在每次使用参数时重新计算，而是保存一个挂起的计算，并在求值后用结果替换或更新它。这是惰性求值的核心运作思想。例如，如果某个函数使用一个计算开销很大的参数两次，按名调用可能会执行两次昂贵的计算，而按需调用则可以复用第一次的结果。共享可以减少重复工作，但也可能让挂起的计算及其环境持续占用内存。\n\n另一个相关区别在于结果的形式。β 正规形的任何位置都不含 β 可归约式。弱头正规形则只显露最外层结构：在纯演算中，它要么是一个抽象，要么是一个变量应用于零个或多个参数。因此，即使抽象的函数体中包含无限计算，该抽象仍可能已处于弱头正规形。这些区别决定了对特定求值器而言，“终止”究竟意味着什么。\n\n求值策略也会影响时间复杂度和内存消耗。一次替换就可能复制一个很大的项，而采用环境或共享图的实现则可能避免实际复制。因此，如果只计算 β 归约步数而不考虑项的大小，就可能对成本作出误导性的估计。形式化分析必须明确归约策略，以及所衡量的资源消耗对应的是哪一种表示方式或机器模型。"
    },
    {
      "heading": "数、数据与控制的编码",
      "text": "没有原生数据，并不妨碍λ演算表示结构化计算。在丘奇编码中，一个值通过使用它的操作来表示。布尔值可以表示为在两个参数之间进行选择：\n\n\\[\\mathsf{TRUE}=\\lambda t.\\lambda f.t, \\qquad \\mathsf{FALSE}=\\lambda t.\\lambda f.f.\\]\n\n于是，条件表达式可以写成\n\n\\[\\mathsf{IF}=\\lambda b.\\lambda p.\\lambda q.b\\,p\\,q.\\]\n\n将一个布尔值应用于两个备选项，就会选出其中之一。不过，在严格求值器中，如果不希望未选中的分支被求值，通常就必须把各个备选项封装在抽象中。编码本身不会改变求值器的求值策略。\n\n丘奇数通过重复应用函数来表示自然数：\n\n\\[\\overline{n}=\\lambda f.\\lambda x.f^{n}(x),\\]\n\n其中，\\(f^{n}(x)\\) 表示将 \\(f\\) 对 \\(x\\) 恰好应用 \\(n\\) 次。特别地，\n\n\\[\\overline{0}=\\lambda f.\\lambda x.x, \\qquad \\overline{2}=\\lambda f.\\lambda x.f(f\\,x).\\]\n\n因此，整数不是用二进制数字串来表示，而是用它作为迭代器的行为来表示。后继、加法和乘法可以表示为\n\n\\[\\begin{aligned} \\mathsf{SUCC} &=\\lambda n.\\lambda f.\\lambda x.f(n\\,f\\,x),\\\\ \\mathsf{ADD} &=\\lambda m.\\lambda n.\\lambda f.\\lambda x.m\\,f\\,(n\\,f\\,x),\\\\ \\mathsf{MUL} &=\\lambda m.\\lambda n.\\lambda f.\\lambda x.m\\,(n\\,f)\\,x. \\end{aligned}\\]\n\n例如，\\(\\mathsf{ADD}\\,\\overline{2}\\,\\overline{3}\\) 可归约为 \\(\\overline{5}\\)。乘法的做法是，把 \\(n\\) 所表示的重复操作作为一个整体，再重复 \\(m\\) 次。\n\n类似地，序对可以通过让使用它的函数访问两个分量来表示：\n\n\\[\\begin{aligned} \\mathsf{PAIR}&=\\lambda a.\\lambda b.\\lambda s.s\\,a\\,b,\\\\ \\mathsf{FST}&=\\lambda p.p\\,\\mathsf{TRUE},\\\\ \\mathsf{SND}&=\\lambda p.p\\,\\mathsf{FALSE}. \\end{aligned}\\]\n\n序对并不是内置的内存记录，而是一个向选择器提供自身分量的函数。这说明了为什么仅凭函数就足以表达许多常见的数据结构。带标签的备选项也可以采用类似的技术，为各个可能的情形分别接收一个处理函数。\n\n丘奇列表通过折叠操作来表示序列，从而推广了丘奇数。一种定义方式是\n\n\\[\\begin{aligned} \\mathsf{NIL}&=\\lambda c.\\lambda n.n,\\\\ \\mathsf{CONS}&=\\lambda h.\\lambda t.\\lambda c.\\lambda n. c\\,h\\,(t\\,c\\,n). \\end{aligned}\\]\n\n列表以空列表情形对应的值 \\(n\\) 为起点，将其元素交给组合函数 \\(c\\) 处理。选择不同的处理函数，就可以计算总和、构造变换后的序列，或检验某种性质。\n\n这些编码证明的是表达能力上的充分性，而不是在所有情况下都能高效执行。丘奇数的大小会随其表示的数值增长，而在机器整数上只需常数时间的操作，在这里可能需要多次归约。包括斯科特编码在内的其他表示方式，则能更直接地支持分类讨论。实际的编程语言通常采用原生数值、代数数据类型和专门的存储方式，而这些编码揭示了此类机制与最小化的函数式核心之间的联系。"
    },
    {
      "heading": "递归、不动点与可计算性",
      "text": "在纯 λ 演算中，函数没有可供其调用自身的内置名称。不过，可以借助不动点组合子实现递归。项 \\(F\\) 的不动点是满足 \\(X=_\\beta F\\,X\\) 的项 \\(X\\)。柯里的不动点组合子为\n\n\\[Y=\\lambda f. (\\lambda x.f(x\\,x)) (\\lambda x.f(x\\,x)).\\]\n\n对于任意 \\(F\\)，应用 \\(Y\\) 所得到的项都与 \\(F(YF)\\) β 可转换。因此，无须添加专门的递归定义构造，也能表达自引用。\n\n令\n\n\\[A=\\lambda x.F(x\\,x).\\]\n\n这样就能更清楚地看出归约过程：\\(YF\\) 归约为 \\(A\\,A\\)，而 \\(A\\,A\\) 又归约为 \\(F(A\\,A)\\)。同一个能够自我复制的子项被传给 \\(F\\)，充当递归引用。这种构造并不是说，通常意义上的有限数学函数会等于对其自身施加任意数值变换的结果。它建立的是演算中各项之间的等式，而这种演算允许求值发散。\n\n例如，要表达阶乘，可以先写出一个非递归的泛函，将递归运算作为参数传入：\n\n\\[F=\\lambda r.\\lambda n. \\mathsf{IF}\\,(\\mathsf{ISZERO}\\,n)\\, \\overline{1}\\, (\\mathsf{MUL}\\,n\\,(r\\,(\\mathsf{PRED}\\,n))).\\]\n\n随后，\\(YF\\) 就提供了递归所需的自引用。在适当的非严格求值策略下，输入为零时会直接返回 \\(\\overline{1}\\)，而不对递归分支求值。在按值调用下，这种直接的写法需要调整：普通的 \\(Y\\) 组合子展开得过于急切，各分支也需要延迟求值。适用于按值调用的不动点组合子通过引入额外的抽象来推迟递归调用。\n\n通过适当的编码，λ 项可以表示所有偏递归函数，由此确立了 λ 演算的图灵完备性。“偏”这一限定至关重要：对于某些输入，求值可能不终止，因而项可能无法返回表示数的项。λ 演算与图灵机的等价性，指的是两者能够计算什么，而不是对应的计算是否具有相同的运行时间、内存需求或实现成本。\n\n这种表达能力也带来了不可判定性。不存在一种算法，能够对每个无类型 λ 项判定它是否具有 β 正规形。任意两项之间的 β 可转换性同样是不可判定的。这些结果与停机问题有关，但其精确表述针对的是表达式和归约的性质，而不是某台特定机器的停机指令。\n\n不动点的存在也标示了不受限制的系统与强规范化系统之间的一条重要界线。允许一般递归不动点算子的演算，无法保证每个良构程序都会终止。因此，类型化语言会有意识地作出选择：有些允许不受限制的递归，并接受可能发生的发散；另一些则通过要求递归参数在结构上递减或施加其他条件来限制递归，从而确保被接受的定义能够终止。"
    },
    {
      "heading": "类型及其与逻辑的对应",
      "text": "类型系统为项赋予类型，并限制哪些函数应用是允许的。在简单类型λ演算中，类型由基本类型和函数类型 \\(A\\to B\\) 构成。判断 \\(\\Gamma\\vdash M:A\\) 表示：在关于自由变量的假设 \\(\\Gamma\\) 下，\\(M\\) 具有类型 \\(A\\)。其核心规则是\n\n\\[\\frac{\\Gamma,x:A\\vdash M:B} {\\Gamma\\vdash\\lambda x:A.M:A\\to B}, \\qquad \\frac{\\Gamma\\vdash M:A\\to B\\qquad\\Gamma\\vdash N:A} {\\Gamma\\vdash M\\,N:B}.\\]\n\n抽象用于构造函数；应用则要求实参具有该函数所要求的输入类型。\n\n这些限制排除了不受约束的自应用。在通常的简单类型系统中，要为 \\(x\\,x\\) 赋予类型，就必须让 \\(x\\) 同时具有某个类型 \\(A\\) 和函数类型 \\(A\\to B\\)，由此产生的循环约束无法在有限的简单类型中满足。因此，\\(\\Omega\\) 和无类型的 \\(Y\\) 组合子都无法获得类型。纯简单类型演算具有强规范化性质：从任何类型正确的项出发，每一条β归约序列都会终止。若为语言加入任意递归，即使类型系统在其他方面仍然健全，也不再能保证这一点。\n\n柯里—霍华德对应将这些类型规则解释为逻辑学规则。类型 \\(A\\to B\\) 对应于蕴涵。从一个假定具有类型 \\(A\\) 的值出发，构造一个结果类型为 \\(B\\) 的函数，对应于在假设 \\(A\\) 下证明 \\(B\\)，然后消去这一假设。应用对应于肯定前件推理。例如，恒等项 \\(\\lambda x:A.x\\) 对应于 \\(A\\to A\\) 的一个证明。β归约则对应于消除一种证明中的迂回：先引入一个蕴涵，随即又使用它。\n\n更丰富的类型演算能够表达更丰富的逻辑结构和程序结构。系统F由让-伊夫·吉拉尔和约翰·雷诺兹于20世纪70年代初各自独立提出，它加入了对类型的全称量化。其多态恒等函数具有如下类型：\n\n\\[\\forall A.\\,A\\to A.\\]\n\n同一个定义无须改写，就可以在多种类型上实例化。多态性也支持丘奇编码的精确类型化版本，不过，在完整的系统F中，不受限制的类型推断是不可判定的。实用编程语言通常采用限制更多的多态形式，以便让类型推断更易于处理。\n\n依赖类型允许类型依赖于项。向量类型可以记录向量的长度，函数的结果类型则可以表达关于其输入的命题。在证明解释下，依赖函数类型对应于全称量化。这类演算是证明助手的重要基础，其中包括将数学证明作为带类型的项来检查的系统。\n\n这种对应要求对演算作出严谨的规定。并非每一种带类型的编程语言都会自动构成一致的逻辑：不受限制的递归可以为每个类型构造出一个不终止的项，而效应或额外公理则需要单独解释。因此，面向证明的系统会控制递归，并谨慎规定类型宇宙和消去规则。类型保持性和进展性是编程语言安全性的核心性质，但它们也不同于规范化和逻辑一致性。"
    },
    {
      "heading": "数学模型与程序等价性",
      "text": "归约规则解释表达式如何变换，而数学语义则追问表达式指称什么。操作语义通过状态转移、判断或抽象机的执行步骤来描述求值。指称语义则将项映射为数学对象，使复合项的含义由其各组成部分的含义决定。这两种方法研究的问题彼此相关，却又有所不同：前者规定执行过程，后者则提供可用于研究等式和程序性质的数学结构。\n\n对于简单类型 Lambda 演算，一种基本的解释方式是为每个基本类型指定一个集合，并将 \\(A\\to B\\) 解释为从 \\(A\\) 的解释到 \\(B\\) 的解释的函数所构成的集合。抽象表示函数，应用表示函数求值。这种解释很自然，因为类型区分了实参和作用于这些实参的函数。在这样的解释下，贝塔归约保持含义不变，而伊塔等价则体现了函数的外延相等性。\n\n无类型演算的建模更为困难。所有项都属于同一个论域，既可以出现在函数位置，也可以出现在实参位置。如果朴素地尝试将一个非平凡集合 \\(D\\) 与所有函数 \\(D\\to D\\) 构成的集合等同起来，就会遇到基数上的障碍。这并不意味着无类型 Lambda 演算没有数学模型；它表明，不受限制的普通函数空间无法提供所需的构造。\n\n达纳·斯科特在 1969—1970 年前后的工作利用域理论中发展出的结构，建立了影响深远的模型。这些结构对部分信息加以组织，并支持适当类别的连续函数。递归的域构造能够容纳无类型演算所需的函数自指。最小元通常记作 \\(\\bot\\)，可用于表示未定义的信息或不终止的计算。具体项的确切解释取决于所采用的模型，而不能仅凭这个记号确定。\n\n因此，必须区分几种不同的等价概念。两个项可能是贝塔可转换的、贝塔–伊塔可转换的、在选定的指称模型中相等的，或是在某种语言中无法通过观察加以区分的。上下文等价通常指：任何允许的外围程序上下文，都无法通过该语言规定的观察方式（例如是否终止或返回的数据）区分这两个项。其定义取决于求值策略、可用的原语以及可观察的效应。\n\n如果一种语义能够正确刻画相关的操作层面观察，就称其具有充分性；完全抽象性则要求语义相等与上下文等价恰好一致。这些性质是实质性的数学要求，并不是为项赋予含义后就会自动得到的结果。当语言包含可变状态、异常、控制算子或并发机制时，这些性质尤其难以处理。Lambda 演算为研究这些区别提供了一个受控的环境，而对它的扩展则用于检验：引入额外的计算行为后，纯函数式推理还能在多大程度上成立。"
    },
    {
      "heading": "实现、语言设计与验证",
      "text": "通过复制语法结构来直接实现 β 归约，原理上很简单，但代价可能很高。替换可能会复制庞大的实参，需要反复重命名，还可能遍历项的大部分结构。因此，实际实现通常将函数值表示为闭包：它由函数体的代码以及为其自由变量提供值的环境组成。应用闭包时，只需向环境中添加一个实参绑定，而不必在整个函数体中实际替换实参。\n\n抽象机为这些实现选择提供了精确的描述。Landin 的 SECD 机围绕栈、环境、控制部件和转储区来组织执行。Krivine 机与按名调用求值相关，而 CEK 类抽象机则使用控制、环境和续延来描述按值调用求值。每种抽象机都为 λ 项选定了一种特定的操作解释。正确性论证则将机器的状态转移与相应的高层求值规则联系起来。\n\n惰性实现通常采用图归约，将项或暂缓执行的计算表示为共享的图节点。求值得到结果后，更新共享节点便能让后续请求复用这一结果。这样无需反复进行文本替换，就能实现按需求值。不过，这也带来了一些实际问题：保留下来的环境可能使原本不再需要的数据继续存活，而求值时的更新必须维持预期的共享方式。垃圾回收可以回收不可达的图节点，却无法回收那些仍可通过尚未求值的计算访问到的值。\n\n编译器变换也直接借鉴了 λ 演算的思想。闭包转换将捕获的环境显式化。λ 提升将自由变量转化为额外的函数形参。续延传递风格将计算的后续部分表示为显式的函数实参，从而显露求值顺序和控制转移。这些变换有助于优化高阶程序，以及编译异常、续延等语言特性。它们的正确性取决于是否保持了作用域、求值行为和可观察到的效果，而不仅仅是函数表达式在形式上是否相似。\n\n这种影响并不限于通常归类为函数式语言的语言。JavaScript 和许多其他多范式语言都支持匿名函数和词法闭包，而高阶函数已成为现代编程中广泛使用的标准库工具。不过，名为“lambda”的匿名函数构造并不一定是纯 λ 演算的直接实现。它的行为取决于宿主语言对可变状态的规则、对象模型、调用约定，以及处理捕获变量的方式。\n\n各种 λ 演算还在形式验证中充当中间语言和规约工具。小型核心语言使得陈述类型保持性、证明编译器各趟变换的正确性，或定义证明检查器的可信内核变得切实可行。对于具有正规化性质的演算，通过求值进行正规化的方法先将项解释到一个语义域中，再将其含义具化为语法，从而计算出正规形。绑定始终是验证中反复出现的难题，可以通过具名语法、de Bruijn 表示法、局部无名技术，以及经过机器检查的替换引理来处理。"
    }
  ],
  "links": [
    "formal-language",
    "turing-machine",
    "computer-science",
    "functional-programming",
    "alonzo-church",
    "mathematics",
    "alan-turing",
    "church-turing-thesis",
    "programming-language",
    "john-mccarthy",
    "lisp-programming-language",
    "compiler",
    "time-complexity",
    "data-structure",
    "recursion",
    "turing-completeness",
    "algorithm",
    "halting-problem",
    "type-system",
    "curry-howard-correspondence",
    "logic",
    "proof-assistant",
    "garbage-collection",
    "continuation-passing-style",
    "javascript",
    "formal-verification"
  ],
  "sources": [],
  "license": "https://creativecommons.org/licenses/by/4.0/"
}