递归函数、λ 演算与图灵机的等价性-2

华仔142

已于 2024-01-03 13:16:15 修改

阅读量442

点赞数 8

文章标签：前端 javascript 算法

于 2024-01-02 17:19:33 首次发布

本文链接：https://blog.csdn.net/weixin_60738001/article/details/135345582

版权

等价性证明

前文：递归函数、λ 演算与图灵机的等价性-1

模型之间的等价性证明是通过相互模拟实现的，即如果两个模型之间可以相互模拟，那么说明这两个模型所定义的“可计算”问题类是相同的。这里先给出模拟的简单思路。

图灵机是最符合人类计算模式的计算模型，根据部分递归函数与Lambda演算的定义和运算规则，我们可以模拟其递归调用过程或归约过程，正如我们手动进行函数计算和归约一样。
Lambda演算天然地用来表示函数计算，所以我们可以用Lambda演算模拟部分递归函数的调用过程。
将图灵机的格局采用一定的编码方式编码为自然数，可以使用函数来模拟图灵机的运算，所以可采用递归函数模拟图灵机的计算过程。

模拟某一计算模型时的关键点如下：

模拟图灵机：需要对其格局编码，需要模拟读纸带，状态改变，写纸带，即模拟格局的合法迁移
模拟部分递归函数：模拟基本函数+运算规则（广义合成、原始递归以及无界 $\mu$ 运算），还要注意处理递归调用的问题。
模拟Lambda演算：模拟 $\beta$ 归约，检查是否等价

不妨假设：

图灵机仅使用三种带符号，即 $\Gamma = \{ 0, 1, \lambda\}$ ，其中 $\lambda$ 为空符号。
当图灵机到达接受态时，将读头置于最左侧。

部分递归函数 $\Longrightarrow$ 图灵机

证明给定的部分递归函数 $\mathbb{N} \to \mathbb{N}$ 可以由图灵机计算，只需要用图灵机模拟基本函数+运算规则，注意利用归纳条件。

模拟常函数 $C_{m}^{(n)}: \mathbb{N}^{n} \rightarrow \mathbb{N}$

设 $M_C$ 为 $n + 1$ 带图灵机，其中 $n$ 带为输入 $x_{1}, x_{2}, \ldots, x_{n}$ ， $1$ 带为工作带，满足：

不管前 $n$ 带输入，直接在第 $n + 1$ 带上打印常数 $C$ 。

模拟后继函数 $\mathbb{N} \rightarrow \mathbb{N}$

设 $M_S$ 为 $2$ 带图灵机，输入带写有输入 $n$ ，满足：

在工作带上打印 $n + 1$ （二进制加法可由图灵机模拟）

模拟投影函数 $P^{n}:\mathbb{N}^{n} \rarr \mathbb{N}$

设 $M_{P^n_i}$ 为 $n + 1$ 带图灵机，其中 $n$ 带为输入 $x_{1}, x_{2}, \ldots, x_{n}$ ， $1$ 带为工作带，满足：

将第 $i$ 条带的内容复制到工作带上。

模拟广义合成 $\circ\left(g_{1},g_{2}, \ldots, g_{m})\right.$

设 $M_h$ 模拟函数 $h$ 的计算， $M_{g_1}, M_{g_2},~\cdots~,M_{g_m}$ 模拟函数 $g_{1},g_{2}, \ldots, g_{m}$ 的计算，构造图灵机 $M_{f}$ 如下：

对于输入 $x_{1}, x_{2}, \ldots, x_{n}$ ，运行机器 $M_{g_1}, M_{g_2},~\cdots~,M_{g_m}$
将1的输出 $y_{1}, y_{2}, \ldots, y_{m}$ 作为 $M_h$ 的输入，运行 $M_h$
输出 $M_h$ 的运行结果

模拟原始递归

$\begin{aligned} \begin{cases} f\left(x_{1}, x_{2}, \ldots, x_{n}, 0\right) &= g\left(x_{1}, x_{2}, \ldots, x_{n}\right) \\ f\left(x_{1}, x_{2}, \ldots, x_{n}, y^{+}\right)&= h(x_{1}, x_{2}, \ldots, x_{n}, y,\left.f\left(x_{1}, x_{2}, \ldots, x_{n}, y\right)\right) \end{cases} \end{aligned}$

设 $M_g$ ， $M_h$ 分别模拟 $g$ 和 $h$ 的计算，构造图灵机 $M_{f}$ 如下：

$M_f$ 共有 $n + 4$ 条纸带
- $n + 1$ 条用于输入 $x_{1}, x_{2}, \ldots, x_{n},y$
- 第 $n + 2$ 条用于计数cnt
- 第 $n + 3$ 条用于记录中间结果
- 第 $n + 4$ 条用于工作/输出

如果 $y = 0$ ，在输入 $x_{1}, x_{2}, \ldots, x_{n}$ 上运行 $M_g$ ，输出在第 $n + 4$ 条纸带上
如果 $y\neq 0$ ，则在第 $n + 2$ 条带上写下0，在第 $n + 3$ 条带上写下在输入 $x_{1}, x_{2}, \ldots, x_{n}$ 上运行的输出；
以 $x_{1}, x_{2}, \ldots, x_{n}$ 第 $n + 2$ 和 $n + 3$ 带为输入，运行 $M_h$ ，将输出写到第 $n + 3$ 条纸带上。
如果 $c n t = y - 1$ ，则将第3条纸带的内容复制到第 $4$ 条纸带，作为输出；
否则，将 $c n t 加 1$ ，并跳转到 3 执行。

模拟 $\mu$ 运算

设 $M_g$ 模拟了函数 $g$ 的运算，构造图灵机 $M_{f}$ 如下：

输入 $x_{1}, x_{2}, \ldots, x_{n}$ 后，将 $0$ 写到第 $n + 1$ 带，记为 $y$
以 $x_{1}, x_{2}, \ldots, x_{n},y$ 为输入，运行 $M_g$
如果之前的执行停止并输出0，则停止并输出 $y$ 。
否则，将 $y$ 改写为 $y + 1$ ，并执行步骤2。

因此，可以使用图灵机模拟基本函数+所有运算规则。因此，可以使用图灵机模拟任何部分递归函数。

图灵机 $\Longrightarrow$ 部分递归函数

图灵机格局

在这里插入图片描述

任意给定图灵机 $\left(Q, \Sigma, \Gamma, \delta, q_{0}, q_{\mathrm{accept}}, q_{\mathrm{reject}}\right)$ ，构造递归函数 $\mathbb{N} \rightarrow \mathbb{N}$ ，使 $f$ 能够模拟图灵机的计算。

由于部分递归函数是自然数集 $\mathbb{N}$ 上的函数，而图灵机的格局是（字符串，状态号和读头下标）构成的3元组，需要将字符串唯一且有效地编码为自然数。

字符串编码

使用哥德尔编码思想，对于给定字符集大小 $|\Gamma| = K$ ，建立字符到自然数的双射 $\Gamma \rightarrow \mathbf{K}$ ，对于字符串 $s_{1} s_{2} s_{3} \ldots s_{n}$ ，其编码为：

$h\left(s_{1}\right) \times K^{0}+ h\left(s_{2}\right) \times K^{1}+\cdots+ h\left(s_{n-1}\right) \times K^{(n-2)}+ h\left(s_{n}\right) \times K^{(n-1)}$

我们假设图灵机仅使用 $3$ 种带符号，则 $K = 3$

图灵机计算格局编码

使用 $\langle w, q, p\rangle$ 表示 $M$ 的计算格局，即当前带上串为 $w$ ， $M$ 状态为 $q$ ，读头位于 $p$ 。

带上串使用哥德尔数编码 $w$
机器状态编码： $q_0 \rightarrow 0, q_1 \rightarrow 1, \cdots, q_{(r-1)} \rightarrow r-1$ ，共有 $r$ 种不同的状态。
读头位置 $p$

利用原始的哥德尔编码，有：
$\operatorname{config}(w,q,p) = 2^{w} \cdot 3^{q} \cdot 5^{p}$
对于合法的格局迁移： $\langle w, q, p\rangle \rightarrow \langle w', q', p'\rangle$ ，我们需要用递归函数编码并计算其对应的 $w^{'}, q^{'}, p^{'}$ ，利用状态转移函数 $\delta: Q \times \Gamma \rightarrow Q \times \Gamma \times\{\mathrm{L}, \mathrm{R}\}$ 。

读头移动方向
$\operatorname{action}(q, s)= \left\{ \begin{array}{l} 0, \quad & \delta (q, s) = (q', c, \textbf{L}) \\ 1, \quad & \delta (q, s) = (q', c, \textbf{R})\\ 2, \quad & \textbf{otherwise} \end{array} \right.$
要写下的符号
$\operatorname{next-symbol}(q, s) = \left\{ \begin{array}{l} s', \quad &\delta (q, s) = (q', \textbf{s}', L/R) \\ s, \quad &\textbf{otherwise} \end{array} \right.$
下一状态
$\operatorname{next-state}(q, s) = \left\{ \begin{array}{l} q',& \quad \delta (q, s) = (q', s', L/R) \\ r, & \quad \textbf{otherwise} \end{array} \right.$
这三个函数是通过条件判断定义的函数，也是原始递归的，因为使用条件对应的原始递归谓词构造的分段函数也为原始递归函数。

当前读头读入符号

$\operatorname{cur-symbol}(w, p) = \left(w / 3^{p \dot{-} 1}\right) \bmod 3$
读头下一位置
$\operatorname{next-position}(w,q,p) = p \dot{-}(\operatorname{action}(q, s)=0)+(\operatorname{action}(q, s)=1)$
纸带下一内容
$\operatorname{next-tape}(w, q, p) = w \dot{-}\left(s \cdot 3^{p \dot{-}1}\right)+\left(\right. \operatorname{next-symbol} \left.(q, s) \cdot 3^{p \dot{-}1}\right)$
图灵机下一计算格局
$\operatorname{next-config}(w, q, p) = \operatorname{config}(w', q', p')$
其中：

$\operatorname{next-tape}(w, q, p)$
$\operatorname{next-state}(q, \operatorname{cur-symbol}(w, p))$
$\operatorname{next-position}(w,q,p)$

从起始状态执行 $t + 1$ 步后获得的格局，由如下原始递归形式给出：
$\operatorname{execute}(w, 0)=2^{w} 3^{0} 5^{1}$
$\begin{aligned} \operatorname{execute}(w, t+1)=\operatorname{next-config}( &[\operatorname{execute}(w, t)]_0,\\ &[\operatorname{execute}(w, t)]_1,\\ &[\operatorname{execute}(w, t)]_2) \end{aligned}$
为完整表述图灵机在输入串w上的运行结果，我们定义图灵机执行的最大步数num-steps：
$\begin{aligned} \operatorname{num-steps}(w) = \mu t [ & ~[E]_2 = 1 \quad \text{and} \\ & ~Enc([E]_0) \quad \text{and} \\ & ~\operatorname{next-state}([E]_1, \operatorname{cur-symbol}([E]_0, [E]_2)) = r] \end{aligned}$
其中 $E n c (*)$ 判断给定的输入是否为合法字符串编码。若 $M$ 停机，则 $\operatorname{num-steps}(w)$ 返回执行的最大步数；若 $M$ 不停机，则 $\operatorname{num-steps}(*)$ 在 $w$ 上无定义。

则给出完整的递归函数形式：

$\left\{ \begin{array}{l} 0, \quad \textbf{if} \quad [\operatorname{execute(N, \operatorname{num-steps}(N))}]_0 = 1 \\\\ j, \quad \textbf{if} \quad 1 \leq j ~\textbf{and}~ \mu j ([\operatorname{execute}(N, \operatorname{num-steps}(N))]_0 = 3^j - 1) \\\\ \uparrow, \quad \textbf{if} \quad \operatorname{num-steps}(N) \uparrow \end{array} \right.$

其中， $N$ 是自然数 $n$ 的哥德尔编码。

如果 $M$ 在 $w$ 上停机且接收，则 $f (n) = 0$ 。
如果 $M$ 在 $w$ 上停机拒绝，则 $f (n) = j$ 。
如果 $M$ 在 $w$ 上不停机，则 $\operatorname{num-steps}(w)$ 没有定义， $f (n)$ 没有定义。

部分递归函数 $\Longrightarrow$ $\lambda$ 演算

常函数
$L_C \triangleq \lambda x. c_0$
$L_C~c_n = (\lambda x.c_0)c_x = _\beta c_x$
后继函数
$L_S \triangleq \lambda c_n.\lambda f.\lambda x . f(c_n(f ~ x))$
$\begin{aligned} L_S~c_n &= (\lambda c_n.\lambda f.\lambda x . f(c_n(f ~ x))) ~c_n \\ & =_\beta \lambda f.\lambda x.f(c_n(f ~ x)) \\ & = \lambda f.\lambda x.f(f^n(x)) \\ & = \lambda f.\lambda x.f^{n+1}(x)) \\ & = c_{n+1} \end{aligned}$
投影函数
$L_{P_{i}^{k}} \triangleq \lambda x_{1} \ldots x_{m} . x_{i}$
$\begin{aligned} L_{P_{i}^{k}} (c_{n_1}, \ldots c_{n_m}) &= (\lambda x_{1} \ldots x_{m} . x_{i}) \quad c_{n_1}, \ldots c_{n_m} \\& =_\beta c_{n_i} \end{aligned}$
广义合成
假设：

$\mathbb{N}^{l} \rightarrow \mathbb{N}$ 是 Lambda可定义的，且 $G\in \Lambda$ 是对应的Lambda项；
$h_{1}, \ldots, h_{l}: \mathbb{N}^{m} \rightarrow \mathbb{N}$ 是 Lambda可定义的，且 $H_1, \ldots,H_l\in \Lambda$ 分别是对应的Lambda项；

函数 $\mathbb{N}^m \rightarrow \mathbb{N}$ 定义如下：

$f\left(n_{1}, \ldots, n_{m}\right)=g\left(h_{1}\left(n_{1}, \ldots, n_{m}\right), \ldots, h_{l}\left(n_{1}, \ldots, n_{m}\right)\right)$

$f$ 是Lambda可定义的，其Lambda项为 $F$ ：

$\triangleq \lambda x_{1} \ldots x_{m} .\left(G~\left(H_{1} ~x_{1} \ldots x_{m}\right) \ldots\left(H_{l} ~x_{1} \ldots x_{m}\right)\right.)$

$\begin{aligned} F(c_{n_1}, \ldots c_{n_m}) &= \lambda x_{1} \ldots x_{m} .\left(G~\left(H_{1} ~x_{1} \ldots x_{m}\right),~ \ldots,~\left(H_{l} ~x_{1} \ldots x_{m}\right)\right.) \quad c_{n_1}, \ldots c_{n_m} \\&=_\beta G ~ H_1(c_{n_1}, \ldots c_{n_m}), \ldots, ~H_l(c_{n_1}, \ldots c_{n_m}) \\&=_\beta G ~c_{h_1(n_1, \ldots n_m)},\ldots, ~c_{h_l(n_1, \ldots n_m)} \\&=_\beta c_{g(h_1(n_1, \ldots ,n_m), \ldots,h_l(n_1, \ldots ,n_m))} \\&=_\beta c_{f(n_1, \ldots ,n_m)} \end{aligned}$

原始递归

定义元组对 $\langle P, Q\rangle \triangleq \lambda f.f(P,~Q)$

解包函数：

$\pi_{1} \triangleq \lambda x . \lambda y \cdot x$ ，有 $\langle P,Q \rangle ~ \pi_1 = P$
$\pi_{2} \triangleq \lambda x . \lambda y \cdot y$ ，有 $\langle P,Q \rangle ~ \pi_2 = Q$

其实解包函数就是我们之前提到过的bool变量true和false。下面给出对原始递归的Lambda定义。

假设：

$\mathbb{N}^{l} \rightarrow \mathbb{N}$ 是 Lambda可定义的，且 $G\in \Lambda$ 是对应的Lambda项；
$\mathbb{N}^{m+2} \rightarrow \mathbb{N}$ 是 Lambda可定义的，且 $H\in \Lambda$ 是对应的Lambda项；

函数 $\mathbb{N}^m \rightarrow \mathbb{N}$ 定义如下：

$\begin{aligned} \begin{cases} f\left(n_{1}, n_{2}, \ldots, n_{m}, 0\right) &= g\left(n_{1}, n_{2}, \ldots, n_{m}\right) \\ \\ f\left(n_{1}, n_{2}, \ldots, n_{m}, y^{+}\right)&= h(n_{1}, n_{2}, \ldots, n_{m}, y,\left.f\left(n_{1}, n_{2}, \ldots, n_{m}, y\right)\right) \end{cases} \end{aligned}$

$f$ 是 Lambda 可定义的，其 Lambda 项 $F$ 为：

$\begin{array}{l}F=\lambda x . \lambda x_{1} \ldots \lambda x_{m} . (x~~ T(\left\langle c_{0}, ~G~ x_{1}, \ldots, x_{m}\right\rangle) ~~\pi_{2}) \end{array}$

其中

$T=\lambda p .\left\langle\mathbf{S}^{+}\left(p ~\pi_{1}\right), H\left(p ~\pi_{2}\right),\left(p ~\pi_{1}\right), x_{1}, \ldots ,x_{m}\right\rangle$

首先对于 $k$ 做归纳：

$\begin{aligned} T^{0}\left\langle c_{0}, G~ c_{n_{1}} \ldots c_{n_{m}}\right\rangle & =_{\beta} \left\langle c_{0},~ G ~c_{n_{1}}, \ldots ,c_{n_{m}}\right\rangle \\ &=_{\beta}\left\langle c_{0}, ~c_{g\left(n_{1}, \ldots, n_{m}\right)}\right\rangle \\& =_{\beta}\left\langle c_{0},~ c_{f\left(0, n_{1}, \ldots, n_{m}\right)}\right\rangle \end{aligned}$

$\begin{aligned} T^{k+1}\left\langle c_{0}, G ~c_{n_{1}} \ldots c_{n_{m}}\right\rangle &=_{\beta} T\left(T^{k}\left\langle c_{0}, G ~c_{n_{1}} \ldots c_{n_{m}}\right\rangle\right) \\ & =_{\beta} T\left\langle c_{k}, c_{f\left(k, n_{1}, \ldots, n_{m}\right)}\right\rangle \\ & =_{\beta} \left\langle\mathbf{S}^{+} c_{k}, H~ c_{f\left(k, n_{1}, \ldots, n_{m}\right)}, c_{k}, c_{n_{1}}, \ldots ,c_{n_{m}}\right\rangle \\ & =_\beta \left\langle c_{k+1}, c_{h\left(f\left(k, n_{1}, \ldots, n_{m}\right), k, n_{1}, \ldots, n_{m}\right)}\right\rangle \\ & =_\beta \left\langle c_{k+1}, c_{f\left(k+1, n_{1}, \ldots, n_{m}\right)}\right\rangle \end{aligned}$
则：
$\begin{aligned} F(c_{k+1}, c_{n_1},\ldots,c_{n_m}) & =_\beta (c_{k+1}~~ T(\left\langle c_{0}, ~G~ n_{1}, \ldots, n_{m}\right\rangle) ~~\pi_{2}) \\& =_\beta T^{k+1}(\left\langle c_{0}, ~G~ n_{1}, \ldots, n_{m}\right\rangle) ~~\pi_{2} \\&=_\beta \left\langle c_{k+1}, c_{f\left(k+1, n_{1}, \ldots, n_{m}\right)}\right\rangle ~\pi_2 \\&=_\beta c_{f\left(k+1, n_{1}, \ldots, n_{m}\right)} \end{aligned}$

$\mu$ 运算

假设 $\mathbb{N}^{m+1} \rightarrow \mathbb{N}$ 是 Lambda可定义的，且 $G\in \Lambda$ 是对应的Lambda项，定义 $f:\mathbb{N}^{m} \rightarrow \mathbb{N}$ 如下：

$f\left(n_{1}, \ldots, n_{m}\right)=\mu n\left[g\left(n, n_{1}, \ldots, n_{m}\right)=0\right]$

是Lambda可定义的，其Lambda项如下：

$\lambda x_1\ldots x_m. H~ c_0$

其中 $H$ 实现了 $n$ 从 $0$ 开始检测 $g\left(n, n_{1}, \ldots, n_{m}\right)=0$ 是否成立：

$H=\mathbf{Y}\left(\lambda f . \lambda y\right..\textbf{if} \left(\right. \operatorname{is-zeo} \left.\left(G ~y, x_{1}, \ldots ,x_{m}\right)\right) \textbf{then} ~y~~ \textbf{else}~ \left.f\left(\mathbf{S}^{+} y\right)\right)$

其中 $\mathbf{Y}$ 为不动点运算子，有：

$H=_{\beta} \lambda y.\textbf{if} (\operatorname{is-zeo} \left.\left(G ~y, x_{1}, \ldots, x_{m}\right)\right) \textbf{then}~ y~~ \textbf{else} ~H\left(\mathbf{S}^{+} y\right)$

综上，我们给出了所有基本函数和运算法则的Lambda定义式，则所有的部分递归函数都是 $λ$ -可定义的。

$\lambda$ 演算 $\Longrightarrow$ 图灵机

需要模拟 $\lambda$ 演算的规则，如：判定是否 $\alpha$ 等价，判定是否为 $\beta$ 范式，模拟 $\beta$ 归约。

为此我们需要：

获取所有变量 $M_{V}$
模拟上下文填充 Context Filling $M_{CF}$
模拟改变约束变量 $M_{CBV}$
检查是否 $\alpha$ 等价 $M_{AC}$
检查是否为 $\beta$ 范式 $M_{BNF}$
模拟 $\beta$ 归约

获取所有变量 $M_{V}$

对于给定的Lambda项 $M\in \Lambda$ ，定义 $M_V$ ：

从最左边的字符开始读取 $M$ 。如果字符 $\in\{ \lambda, ~(, ~), ~.\}$ ，则跳过，否则将字符复制到带子2上并打印出一个 $\#$ 。
在带2上删除所有和 $\#$ 不同的重复字符，得到所有的变量。

模拟上下文填充 Context Filling $M_{CF}$

假设字母表包括一个特殊字符，称之为洞字符。令 $CF$ 为多带图灵机，满足以下条件：

输入：
- 纸带1：上下文Context；纸带2：待填充串；
纸带3：结果带。

开始将纸带1的字符从最左侧复制到纸带3上。
复制字符直到找到一个空洞字符，跳过该字符并执行第3步。
将纸带2的所有内容附加到纸带3中。然后，返回到第2步的复制过程中。

上述过程模拟了将纸带2上的串填充到了纸带1 Context的“空洞”之中。

模拟改变约束变量 $M_{CBV}$ ： $C[\lambda x.N] \Rightarrow C[\lambda y.(N[x\rightarrow y])]$

$M_{CBV}$ ：输入 $x, y, C, N$ 分别写在纸带1、2、3和4上，

在第4个纸带中将所有变量 $x$ 的出现替换为 $y$ 。
在第三个纸带的开头追加λy.(，并在末尾追加一个)字符。
使用带有输入纸带3和4的 $M_{CF}$ 运行。
将 $M_{CF}$ 的结果复制到纸带5中。

检查是否 $\alpha$ 等价 $M_{AC}$ ： $~?=_\alpha N$

两个输入带分别为M和N
在N上运行机器 $M_{V}$ ；
结果带上打印 0；
在从绑定变量更改中获得的树上运行DFS搜索，在每次抽象发生时，将绑定变量与 $V (N)$ 元素的每个变量进行替换。在搜索的每个节点上，检查是否等于 $N$ ，如果是，则在结果带上打印1。

$M_{AC}$ 是否 $\alpha$ 等价。由于 $\in \Lambda$ 是一个有限的符号序列， $V (N)$ 是一个有限集合，那么搜索过程是有限的，并且会停止。

检查是否为 $\beta$ 范式 $M_{BNF}$

给定输入T = (λx.M) 在第一条带上。

在输入带上寻找(λx. 的出现，并匹配括号以找到项 M。如果没有找到 (λx. 的出现，则转到第3步；
如果(λx.M)的右边没有更多的字符，转到步骤3。否则，在结果带上打印0；
在结果带上打印1。

模拟 $\beta$ 归约 $\rightarrow_\beta$

起始状态下，纸带1为输入T=(λx.M)N；

使用 $M_{NF}$ 来检查 T=(λx.M)N 是否处于 $\beta$ 范式。如果是，则停止；
搜索 (λx. 的出现并匹配括号以找到项 $M$ ；
括号匹配找到项 $N$ ；
将 $M$ 中的所有 $x$ 替换为空字符；
以输入 $M$ 和 $N$ 运行 $CF$ ，结果写入带1；
回到第1步。

由Church-Rosser 定理可知， $M_{NF}$ 的输出为唯一的满足 $\beta$ 范式的Lambda项。

综上，利用上述图灵机，对于给定的函数 $\mathbb{N}^{k} \rightarrow \mathbb{N}$ 的Lambda表示 F，可以将 $F(c_{n_1}, \ldots, c_{n_k})$ ，归约得到唯一的满足 $\beta$ 范式 $c_{m} = c_{f(n_1,\ldots, n_k)}$ ，即：

$F(c_{n_1}, \ldots, c_{n_k}) \twoheadrightarrow _\beta c_{f(n_1, \ldots,n_k)}$

也就是使用图灵机模拟了Lambda可定义函数的计算。

结语

我们通过相互模拟证明了三种计算模型的等价性。三种模型虽然等价，但各自却有不同的特点。

图灵不仅引入了“图灵机”，还介绍了能模拟任何图灵机的“通用图灵机”。通用图灵机是所有现代数字计算机的基本逻辑模型。丘奇和哥德尔都认为图灵的可计算性分析更直观、更具有吸引力和说服力，哥德尔起初认为丘奇的Lambda可定义性“完全不令人满意”，而在看到图灵的分析后评价道“…最令人满意的”，“正确的…毫无意义问的”。

丘奇的Lambda演算在程序设计语言理论的发展中发挥了重要的作用，是函数式编程的基础理论，得到了广泛的应用。尽管python主要支持面向对象和过程式的编程范式，我们仍然可以使用python lambda函数来实现一下前文提到的Lambda式与可定义函数。如：

# bool variable
T = lambda x, y: x
F = lambda x, y: y

AND = lambda x, y: x(y, F)
OR = lambda x, y: x(T, y)
NOT = lambda x: x(F, T)

# test AND
assert T == AND(T, T)
assert F == AND(T, F)
assert F == AND(F, T)
assert F == AND(F, F)

# Natural Number
n0 = lambda f, x: x
n1 = lambda f, x: f(x)
n2 = lambda f, x: f(f(x))
n3 = lambda f, x: f(f(f(x)))

INC = lambda N, f, x: f(N(f, x))

INC_beta = lambda N: (lambda f, x: f(N(f, x)))


# Pair
PAIR = lambda M, N: lambda x: x(M, N)
a = 1
b = 2
a_b = PAIR(a, b)