简单易懂的程序语言入门小册子（1.5）：基于文本替换的解释器，递归定义与lambda演算的一些额外说明

这一篇接在第一篇lambda演算的后面。讲讲一些数学知识。

经常有些看似很容易理解的东西，一旦要描述得准确无误，就会变得极为麻烦。 软件工程里也有类似情况：20%的代码实现了核心功能，剩下80%的代码处理边界情况。 于是，所谓的准确描述里的大部分文字都在说明边界情况，核心概念只有寥寥几字——好比一件打满补丁的衣服，完全看不出原来的样子。 出现这种现象要么是人类的大脑有缺陷，难以严谨而又准确的理解概念，也就是说人类太笨； 要么就是语言系统有问题，难以简洁地表达概念，而发明不出新的语言系统的人类还是很笨。 无怪乎“人类一思考，上帝就发笑”。 这一节打算尽量严谨地描述$\lambda$演算里的一些符号的含义，希望不会写得太繁琐。

递归定义

实数的链表$List$一般定义为：

$$\begin{equation*}\begin{array}{lcl}   List &=& {nil} \\        &|& \left<R, List\right> \end{array}\end{equation*}$$ 其中，nil是一个空链表，$\left<A, B\right>$表示包含$A$和$B$的二元组，$R$表示实数集合。

这个文法实际上是定义了一个集合$List$，我用集合运算的符号重写$List$的定义：

$$\begin{equation*}\begin{array}{lcl}   List &=& \{{nil}\} \\     &\cup& \{\left<r, l\right> | r \in R, l \in List\} \end{array} \end{equation*}$$ 这是个递归定义。 递归定义对于没接触过的人来说，其实是很难以理解的。 我们现在觉得递归定义很直观，或许只是{\bf习惯了}这种东西而已。 递归定义难以理解的地方在于，我们在描述定义的地方用到了被定义的事物本身。

比如说，我现在想知道$List$是什么。 这时我脑里有$List$这个符号，但是我还不知道$List$代表什么内容。 然后我就来看这个定义，结果看到定义里的第二行用到了$List$，但是我这时候还没不知道什么是$List$呢！

所以，为了具体解释递归定义到底定义了什么，我下面用一种构造性的方法来定义$List$。

首先，基础情况是空链表nil，构造一个只包含nil的集合，记为$List_0$。

$$List_0 = \{{nil}\}$$ 向nil的添加一个元素可以生成只包含一个元素的链表。 所有只包含一个元素的链表的集合再并上$List_0$就是所有元素个数小于等于1的链表的集合，记为$List_1$。 $$\begin{equation*}\begin{array}{lcl}   List_1 &=& \{{nil}\} \\       &\cup& \{\left<r, l\right> | r \in R, l \in List_0\} \end{array} \end{equation*}$$ 依此类推可以构造包含所有元素个数小于等于2的链表的集合$List_2$，所有元素个数小于等于3的链表的集合$List_3$…… 一般地，可以构造包含所有元素个数小于等于$i$（$i>0$）的链表的集合$List_i$： $$\begin{equation*}\begin{array}{lcl}   List_i &=& \{{nil}\} \\       &\cup& \{\left<r, l\right> | r \in R, l \in List_{i-1}\} \end{array} \end{equation*}$$ 当$i$趋于无穷时，我们就得到了链表的集合$List$： $$List = \lim_{i \rightarrow \infty}{List_i}$$ 顺便一提，这里用到了极限，或许还得解释解释集合的极限是什么意思，这个极限收不收敛等问题。 不过，管他的，理解是什么意思就行。 可以看到，递归定义是一个涉及到“无穷”的定义。 很多东西一旦涉及到无穷就很麻烦。

在$List_i$的定义中让$i$趋向无穷看看会怎样？ 由于当$i$趋向无穷时有$List_i = List_{i-1} = List$，所以我们得到了$List$的递归定义。

下面用同样的思路描述了$\lambda$演算的语法：

$$\begin{equation*}\begin{array}{lcl}   M_0 &=& X \\   M_i &=& X \\    &\cup& \{\lambda x.m | x \in X, m \in M_{i-1}\} \\    &\cup& \{(m \; n) | m \in M_{i-1}, n \in M_{i-1}\} \\   M &=&\displaystyle \lim_{i \rightarrow \infty}{M_i} \end{array} \end{equation*}$$

归约派生的等价关系

数学让人如此讨厌大概是因为它严谨得像处女座一样。 在我们计算$\lambda$演算的表达式时，我们这样写：

$$\begin{equation*}\begin{array}{lcl}   ((\lambda y.\lambda x.(x \; y) \; a) \; \lambda z.z) &=& (\lambda x.(x \; a) \; \lambda z.z) \\   &=& (\lambda z.z \; a) \\   &=& a \end{array} \end{equation*}$$ 嗯？等号$=$具体是什么意思呢？它是$\alpha$归约、$\beta$归约和$\eta$归约的某种混合。 下面解释“某种混合”具体是什么意思。

归约（$\alpha$归约、$\beta$归约和$\eta$归约）实质上是一个集合，这个集合的元素是二元组$\left<m, n\right>$。 这个二元组的意思是$m$可以归约到$n$。 这里混合这三种归约的关系记为符号$\rightarrow$。 “混合”是并集的意思。 $\rightarrow$定义为：

$$\begin{equation*}\begin{array}{lcl} \rightarrow &=& \rightarrow_\alpha \cup \rightarrow_\beta \cup \rightarrow_\eta \end{array} \end{equation*}$$ 简单来说，就是$m \rightarrow n$当且仅当$m \rightarrow_\alpha n$或$m \rightarrow_\beta n$或$m \rightarrow_\eta n$。

$\rightarrow$是不是$=$呢？ 如果是的话我就不会特地选用其他符号了。 我们知道，一个等价关系$=$是一个满足以下三种特性的关系：

1. 自反性：$m = m$，也就是自己等于自己；  
2. 对称性：如果$m = n$，那么$n = m$；  
3. 传递性：如果$m = n$并且$n = l$，那么$m = l$。

用这三个特性扩展$\rightarrow$。扩展后的关系记为$\approx$：

$$\begin{equation*}\begin{array}{rcl}   m &\approx& m \\   m \rightarrow n &\Rightarrow& m \approx n \\   m \approx n &\Rightarrow& n \approx m \\   m \approx n, n \approx l &\Rightarrow& m \approx l \end{array} \end{equation*}$$

$\approx$还不是我们需要的等号$=$！ 看下面例子：

$$\begin{equation*}\begin{array}{rclr}   (\underline{(\lambda y.\lambda x.(x \; y) \; a)} \; \lambda z.z)     &\approx& (\underline{\lambda x.(x \; a)} \; \lambda z.z) & \text{错！}\\   (\lambda y.\lambda x.(x \; y) \; a) &\approx& \lambda x.(x \; a) & \text{对！} \end{array} \end{equation*}$$ 看到这两个表达式的区别吗？ $\approx$只能在“最外层”归约！它不能归约子表达式。

所以，还要在$\approx$的基础上添加最后一个特性，添加后就是$=$了：

$$\begin{equation*}\begin{array}{rcl}   m \approx m' &\Rightarrow& m = m' \\   m = m' &\Rightarrow& \lambda x.m = \lambda x.m' \\   m = m' &\Rightarrow& (m \; n) = (m' \; n) \\   n = n' &\Rightarrow& (m \; n) = (m \; n') \end{array} \end{equation*}$$ 在一个大的表达式中，除去一个子表达式以外的部分叫做这个子表达式的上下文。 上面这个特性的意思就是，一个子表达式的归约和它的上下文无关。

终于讲完$=$是什么意思了。 但是还有一个“小问题”。 $=$的计算过程并非唯一的。 比如下面这个例子：

$$\begin{equation*}\begin{array}{lcl}   (\lambda x.x \; \underline{(\lambda y.y \; a)}) &=& \underline{(\lambda x.x \; a)} = a \\   \underline{(\lambda x.x \; (\lambda y.y \; a))} &=& \underline{(\lambda y.y \; a)} = a \end{array} \end{equation*}$$ 一个先计算参数$(\lambda y.y \; a)$，一个则先在最外层做归约。 计算过程不同产生一个问题： 不同计算过程计算出的答案是否是相同（允许$\alpha$归约意义下的相同，如$\lambda x.x$和$\lambda y.y$算一样）的？ 关注程序语言这一领域的人或许有听过Church-Rosser定理。 这个定理的推论就是这个问题的肯定回答。