essential of Lambda

essential of Lambda是《Lambda-Calculus and Combinators : An Introduction》的摘要版本，提供了lambda部分的内容摘要，实现了一个lambda解释器对例题进行自动解答，最后描述不可判定性。

解释器github地址：https://github.com/wangdxh/essential-of-Lambda

1A lambda定义
1B 替换 substitution
- 范围scope的定义
- 自由变量和绑定变量
- 修改绑定变量
- Substitution
1C β归约 β-reduction
β相等
3B 不动点理论
丘奇数 Church Numerals
递归 Y组合子的应用
不可判定性 undecidable
- 罗素悖论
- 哥德尔数
- 丘奇数
- closed under conversion
- Scott–Curry undecidability theorem

1A lambda定义

假设给出了

1.一个无限的变量（variables）表达式序列：v0,v00,v000,v0000,...；
2.还有一个不同于变量的原子常量（atomic constants）表达式序列，可能是有限的，无限的，或者空（如果该序列是空的，那么系统叫做pure，不为空叫做applied）；
那么λ-terms的表达式集合递归地定义如下：

a. 所有的变量和原子常量都是λ-terms(叫做atoms)
b. 如果M和N是任何λ-terms，那么 (MN) 是一个λ-term，叫做application
c. 如果M是任何λ-term，并且x是任何变量，那么 (λx.M) 是一个λ-term，叫做abstraction

举例：
(λv0.(v0 v00))是λ-term
如果x,y,z是互相不同的变量，那么如下都是λ-terms

(λx.xy)
(x(λx.(λx.x)))
((λy.y)(λx.(xy)))
(λx.(yz))

在2中有两个λx在一个term中，定义中允许，实际过程中不鼓励这样使用；4展示了无意义的抽象：(λx.M)格式，x并没有在M中出现，对任何的输入，函数返回相同结果。

application应用相当于函数调用，M是调用函数，N是参数
abstraction抽象 (λx.M)相当于函数定义，x是参数，M是函数体；当抽象被调用时指的是将M内的x替换成参数，(λx.M)N 指将M内的x替换成N
(λx.x(xy))N = N(Ny)
(λx.y)N = y

‘λ’字符本身不是一个term，‘λx’也不是一个term。
在本文中大写字母M，N等代表任意的λ-terms；字母x,y,z,u,v,w代表变量，默认不同的字母表示不同的变量。

两侧括号有时可以省略，例如：MNPQ指的是(((MN)P)Q), 使用左关联
其他缩写如下：
λx.PQ ---> (λx.(PQ))
λxyz.M ---> (λx.(λy.(λz.M)))

≡符号表示语法格式上的相等 Syntactic identity，指的是语句格式相同
M ≡ N指的是M是和N精确地相同，
如果MN ≡ PQ，那么M ≡ P，N ≡ Q
如果λx.M ≡ λy.P，那么x ≡ y，M ≡ P
默认假设：变量和常量是不同的，应用和抽象是不同的，其句法格式不同。这种假设在任何语言定义的时候都是成立的，将来不会明确声明。
P ≡ M N1 N2 ... Nk(k>=0) 当k==0时，指的是 P ≡ M
T有格式：λx1 x2 ... xn.PQ (n>=0) 当n==0时，指的是T有格式 PQ
Iff指的是if and only if

对λ-terms补齐括号和‘λ’，λ在程序中使用^进行代替
java -jar ./lambda-1.0-SNAPSHOT.jar fullformat d:\github\essential-Lambda\fullformat.txt

abcdef
  ->  (((((ab)c)d)e)f)
xyz(yx)
  ->  (((xy)z)(yx))
(^u.vuu)zy
  ->  (((^u.((vu)u))z)y)
^x.uxy
  ->  (^x.((ux)y))
ux(yz)(^v.vy)
  ->  (((ux)(yz))(^v.(vy)))
^u.u(^x.y)
  ->  (^u.(u(^x.y)))
(^xyz.xz(yz))uvw
  ->  ((((^x.(^y.(^z.((xz)(yz)))))u)v)w)
(^xy.xyy)(^u.uyx)  ->  ((^x.(^y.((xy)y)))(^u.((uy)x)))

1B 替换 substitution

对于λ-terms P和Q，出现关系(occur)指的是P出现在Q中，或者P是Q的一个subterm，或者Q包含(contains)P，递归地定义如下：

P出现在P中
如果P出现在M，或者N中，那么P出现在(MN)中
如果P出现在M中，或者P ≡ x，那么P出现在(λx.M)中
例如((xy)(λx.(xy))) xy出现了2次，x出现了3次

范围scope的定义

对于一个特定的λx.M出现在P中，那么出现的M叫做其左边的λx的范围。
类似函数定义时参数的作用范围，参数作用的范围是函数体
P ≡ (λy.yx(λx.y(λy.z)x))vw
最左边的λy的范围是yx(λx.y(λy.z)x)；λx的范围是y(λy.z)x；左右的λy的范围是z

自由变量和绑定变量

变量x在P中的一次出现被叫做：
bound绑定的，如果它出现在P中的一个λx的范围内
bound and binding 绑定的且正在绑定，当前仅当x指的是λx中的x，即参数
free自由的，如果其他情况

如果x在P中至少有一次binding正在绑定形式的出现，那么x叫做P的一个绑定变量 bound variable；如果x在P中至少有一次自由形式的出现，那么x叫做P的一个自由变量 free varibale
P中自由变量的集合简写为：FV(P)
一个闭项closed term指的是没有任何自由变量的term。

考虑如下term：
xv(λyz.yv)w 全括号形式如下：
(((xv)(λy.(λz.(yv))))w)
最左边的x，v是自由的，最左边的y是绑定且正在绑定的，z也是一样，最右边的y是绑定的，但不是正在绑定，v和w是自由的

P ≡ (λy.yx(λx.y(λy.z)x))vw
所有的四个y是bound绑定的，最左边和最右边的y也是binding的，最左边的x是自由的，中间的x是bound and binding的，最右边的x是绑定的bound，不是binding的，所以P中的自由变量的集合是FV(P)={x,z,v,w}。
在P中x即使自由的，也是绑定的。

获取λterm的自由变量
java -jar ./lambda-1.0-SNAPSHOT.jar freevariables d:\github\essential-Lambda\freevariables.txt

abcdef
  ->  {a,b,c,d,e,f}
xyz(yx)
  ->  {x,y,z}
(^u.vuu)zy
  ->  {v,z,y}
^x.uxy
  ->  {u,y}
ux(yz)(^v.vy)
  ->  {u,x,y,z}
^u.u(^x.y)
  ->  {y}
(^xyz.xz(yz))uvw
  ->  {u,v,w}

修改绑定变量

Change of bound variables, congruence
P包含λx.M的一个出现，y不属于FV(M)
那么替换λx.M为λy.[y/x]M叫做 α-conversion in P 或者 P的改变绑定变量

P ≡α Q 或者P α-converts to Q：
当且仅当P可以经过有限的或者空的α转换序列变成Q
λxy.x(xy) ≡ λx.(λy.x(xy))
≡α λx.(λv.x(xv))
≡α λu.(λv.u(uv))
≡ λuv.u(uv)

如果P ≡α Q，那么 FV(P) = FV(Q)
≡α 关系是反射，传递和对称的
P ≡α P
P ≡α Q，Q ≡α R 那么 P ≡α R
P ≡α Q 那么 Q ≡α P
事实上多数的作品里面≡的意思就是≡α，本书后续章节即为这种意义

Substitution

对于任何M，N，x，定义[N/x]M为替换M中的所有以自由形式出现的x为N，并且为了避免冲突改变bound绑定变量，后的结果
递归的定义如下：

[N/x]x ≡ N
[N/x]a ≡ a                 对于所有的原子a 不等于≡ x
[N/x](PQ) ≡ ([N/x]P [N/x]Q)
[N/x](λx.P) ≡ (λx.P)       P中的如果出现x，也会是绑定的，不是自由的
[N/x](λy.P) ≡ (λy.P)        x不属于 FV(P)
[N/x](λy.P) ≡ (λy.[N/x]P) x属于FV(P)并且y不属于FV(N)
[N/x](λy.P) ≡ (λz.[N/x][z/y]P)  x属于FV(P)并且y属于FV(N)

其中x 不等于≡ y，z是不属于FV(NP)的第一个变量

考虑 [w/x](λw.x)，λw.x表示的是常量函数，返回的是x的值；所以[w/x](λw.x) 替换后的结果应该是一个常量函数，返回w的值；如果直接替换x为w得到的是λw.w，返回的是恒等式，输入w，返回w；根据最后一条规则来计算： N为w， y为w，N ≡ w ≡ y ，y属于FV(N)
[w/x](λw.x) ≡ λz.[w/x][z/w]x
≡ λz.[w/x]x
≡ λz.w

引理：
对于任意的term M，N，变量x
[x/x]M ≡ M
x 不属于FV(M)，那么[N/x]M ≡ M
x 属于FV(M)，那么FV([N/x]M) = FV(N) ∪ (FV(M) - {x})

一个自动替换的程序
java -jar ./lambda-1.0-SNAPSHOT.jar subst d:\github\essential-Lambda\subst.txt

[(uv)/x](^y.x(^w.vwx))
apply(^x.(^y.x(^w.vwx)))->(uv)
to:(^y.(uv)(^w.vw(uv)))

[(^y.xy)/x] (^y.x(^x.x))
apply(^x.(^y.x(^x.x)))->(^y.xy)
to:(^y.(^y.xy)(^x.x))

[(^y.vy)/x] (y(^v.xv))
apply(^x.(y(^v.xv)))->(^y.vy)
to:(y(^a.(^y.vy)a))

[(uv)/x](^x.zy)
apply(^x.(^x.zy))->(uv)
to:(^x.zy)

[(^z.zwvy)/x] (^y.yx(^y.xvy))y
apply(^x.(^y.yx(^y.xvy))y)->(^z.zwvy)
to:(^a.a(^z.zwvy)(^b.(^z.zwvy)vb))y

[(^z.zwvy)/x] (^y.yx(^x.xvy))y
apply(^x.(^y.yx(^x.xvy))y)->(^z.zwvy)
to:(^a.a(^z.zwvy)(^x.xva))y

[(^z.zwvy)/x] (^x.xv(^y.xvy))y
apply(^x.(^x.xv(^y.xvy))y)->(^z.zwvy)
to:(^x.xv(^y.xvy))y

[(^z.zwvy)/x] (^x.xv(^x.xvy))y
apply(^x.(^x.xv(^x.xvy))y)->(^z.zwvy)
to:(^x.xv(^x.xvy))y

1C β归约 β-reduction

(λx.M)N 表示的是一个函数(λx.M)调用，参数是N，

β-contracting,β-reducing
任何 (λx.M)N 形式的term叫做β-redex并且对应的 [N/x]M 叫做它的contractum。
β-redex看着像是β-reduce和index结合体，一个可以做β转换的索引

当且仅当P包含一个 (λx.M)N 的出现，并且替换这个出现为 [N/x]M，得到P'，
我们称为 P β-contracts to P' 或者 P ▷1β P′  P经过一次β 转换得到P'

当且仅当P经过一系列有限的或者空的β转换和改变绑定变量得到Q，我们成为P β归约到Q 记为：P ▷β Q

β相等

当且仅当P经过一系列有限的（可能为空）β转换或者反向β转换，或者改变绑定变量得到Q，我们称：P是β-equal 或者β-convertible to Q，标记为 P =β Q

(∀ i ≤ n−1)(Pi ▷1β Pi+1 或者 Pi+1 ▷1β Pi 或者 Pi ≡α Pi+1),P0 ≡ P, Pn ≡ Q.
举例：
Pi到Pi+1 正向变化为Pi ▷1β Pi+1
Pi到Pi+1 反向变化为Pi+1 ▷1β Pi
P0 ≡(λy.yv)z，P1 ≡ zv，P2 ≡(λx.x)zv
(λy.yv)z ▷β zv 正向
(λx.x)zv ▷β zv 反向
(λy.yv)z =β (λx.x)zv

P经过一次β变化得到Q 记为 P ▷1β Q
P经过一系列 β变化得到Q 记为 P ▷β Q
P经过一系列β变化或者反向β变化得到Q 记为 P =β Q

β归约的例子：
java -jar ./lambda-1.0-SNAPSHOT.jar d:\github\essential-Lambda\reduce.txt

expresson reduce:(^x.xy)(^u.vuu)
(^x.xy)(^u.vuu)
(^u.vuu)y
vyy
expresson reduce:(^xy.yx)uv
(^x.(^y.yx))uv
(^y.yu)v
vu
expresson reduce:(^x.x(x(yz))x)(^u.uv)
(^x.x(x(yz))x)(^u.uv)
(^u.uv)((^u.uv)(yz))(^u.uv)
((^u.uv)(yz))v(^u.uv)
((yz)v)v(^u.uv)
expresson reduce:(^x.xxy)(^y.yz)
(^x.xxy)(^y.yz)
(^y.yz)(^y.yz)y
(^y.yz)zy
zzy
expresson reduce:(^xy.xyy)(^u.uyx)
(^x.(^y.xyy))(^u.uyx)
(^a.(^u.uyx)aa)
(^a.ayxa)
expresson reduce:(^xyz.xz(yz))((^xy.yx)u)((^xy.yx)v)w
(^x.(^y.(^z.xz(yz))))((^x.(^y.yx))u)((^x.(^y.yx))v)w
(^y.(^z.((^x.(^y.yx))u)z(yz)))((^x.(^y.yx))v)w
(^z.((^x.(^y.yx))u)z(((^x.(^y.yx))v)z))w
((^x.(^y.yx))u)w(((^x.(^y.yx))v)w)
(^y.yu)w(((^x.(^y.yx))v)w)
wu(((^x.(^y.yx))v)w)
wu((^y.yv)w)
wu(wv)
expresson reduce:(^xyz.xzy)(^xy.x)
(^x.(^y.(^z.xzy)))(^x.(^y.x))
(^y.(^z.(^x.(^y.x))zy))
(^y.(^z.(^y.z)y))
(^y.(^z.z))
expresson reduce:(^xy.x)(^x.x)
(^x.(^y.x))(^x.x)
(^y.(^x.x))

3B 不动点理论

一个操作或者函数的不动点指的是，将改不动点作为参数进行计算，得到的结果没有改变。例如对于x的平方函数，0和1就是不动点，0和1的平方也还是0和1，2就不是不动点。
combinator组合子，简单地讲，组合子就是指不包含自由变量的λ-term。

the fixed-point theorem
在lambda内存在，一个组合子Y，Yx =β x(YX); 更近一步 Yx ▷β x(Yx)

阿兰图灵Y组合子：
Y ≡ UU, U ≡ λux.x(uux)
Curry-Ros Y组合子：
Y ≡ λx.V V, V ≡ λy.x(yy)
其他组合子：
Y0≡WS(BWB)
Y1≡WI(B(SI)(WI))
组合子验证：对各个组合子进行验证，执行Yx，然后得到多次执行后的结果，从结果中分析出Yx ▷β x(Yx) ▷β x(x(Yx)) ▷β ....
为了避免名称冲突，对各个Y组合字给了不同的名字，分别为：Y，A，E，F ，如下所示：

I = (^x.x)
K = (^xy.x)
S = (^xyz.xz(yz))
B = (^xyz.x(yz))
B' = (^xyz.y(xz))
C = (^xyz.xzy)
W = (^xy.xyy)

U= (^ux.x(uux))
Y=UU
Yx

V = (^y.x(yy))
A = (^x.VV)
Ax

E = WS(BWB)
E
Ex

F = WI(B(SI)(WI))
F
Fx

java -jar ./lambda-1.0-SNAPSHOT.jar d:\github\essential-Lambda\ycombinator.txt
因为Yx可以无限执行下去，需要把函数doreduce(String input)的循环归约次数修改为40，默认执行300次归约。

Y和A的结果比较容易看出来，后面两个组合字需要归约的次数多一些才能看到结果，E和F的归约篇幅比较长，就不展示了

expresson reduce:Yx
(^u.(^x.x(uux)))(^u.(^x.x(uux)))x
(^x.x((^u.(^x.x(uux)))(^u.(^x.x(uux)))x))x
x((^u.(^x.x(uux)))(^u.(^x.x(uux)))x)
x((^x.x((^u.(^x.x(uux)))(^u.(^x.x(uux)))x))x)
x(x((^u.(^x.x(uux)))(^u.(^x.x(uux)))x))
x(x((^x.x((^u.(^x.x(uux)))(^u.(^x.x(uux)))x))x))
x(x(x((^u.(^x.x(uux)))(^u.(^x.x(uux)))x)))
x(x(x((^x.x((^u.(^x.x(uux)))(^u.(^x.x(uux)))x))x)))
expresson reduce:Ax
(^x.(^y.x(yy))(^y.x(yy)))x
(^y.x(yy))(^y.x(yy))
x((^y.x(yy))(^y.x(yy)))
x(x((^y.x(yy))(^y.x(yy))))
x(x(x((^y.x(yy))(^y.x(yy)))))
x(x(x(x((^y.x(yy))(^y.x(yy))))))
x(x(x(x(x((^y.x(yy))(^y.x(yy)))))))
x(x(x(x(x(x((^y.x(yy))(^y.x(yy))))))))
x(x(x(x(x(x(x((^y.x(yy))(^y.x(yy)))))))))

后面会有Y组合字的应用实例

丘奇数 Church Numerals

对于任何一个自然数 n，Church Numerals是一个λ-term，表示 λxy.xⁿy
xⁿy 应为右关联的，即x³y为x(x(xy))，如果写为xxxy在计算时，结果不正确。

0,1,3, 4定义如下，
Z = (^xy.y) # 0 zero
O = (^xy.xy) # 1 one
T = (^xy.(x(x(xy)))) # 3 Three
F = (^xy.(x(x(x(xy))))) # 4 Four

加法：P = (^mnxy.mx(nxy))
PTF 3加4结果应该为7

加一：Q = (^uxy.x(uxy))
QF 4加1 结果为5

减一：A = (^nxy.n(^gh.h(gx))(^u.y)(^u.u))
AZ 0减一还是0
AO

条件表达式：如果z为church 0，返回x，否则返回y
K = (^xy.x)
D = (^xyz.z(Ky)x)
DXYZ = X
DXYO = Y
DXYT = Y

java -jar ./lambda-1.0-SNAPSHOT.jar d:\github\essential-Lambda\church.txt
用户可以补充其他的乘法和减法，进入church.txt，然后通过程序进行结果验证

结果计算如下：

expresson reduce:PTF
(^m.(^n.(^x.(^y.mx(nxy)))))(^x.(^y.(x(x(xy)))))(^x.(^y.(x(x(x(xy))))))
(^n.(^x.(^y.(^x.(^y.(x(x(xy)))))x(nxy))))(^x.(^y.(x(x(x(xy))))))
(^x.(^y.(^x.(^y.(x(x(xy)))))x((^x.(^y.(x(x(x(xy))))))xy)))
(^x.(^y.(^y.(x(x(xy))))((^x.(^y.(x(x(x(xy))))))xy)))
(^x.(^y.(x(x(x((^x.(^y.(x(x(x(xy))))))xy))))))
(^x.(^y.(x(x(x((^y.(x(x(x(xy)))))y))))))
(^x.(^y.(x(x(x(x(x(x(xy)))))))))
expresson reduce:QF
(^u.(^x.(^y.x(uxy))))(^x.(^y.(x(x(x(xy))))))
(^x.(^y.x((^x.(^y.(x(x(x(xy))))))xy)))
(^x.(^y.x((^y.(x(x(x(xy)))))y)))
(^x.(^y.x(x(x(x(xy))))))
expresson reduce:AZ
(^n.(^x.(^y.n(^g.(^h.h(gx)))(^u.y)(^u.u))))(^x.(^y.y))
(^x.(^y.(^x.(^y.y))(^g.(^h.h(gx)))(^u.y)(^u.u)))
(^x.(^y.(^y.y)(^u.y)(^u.u)))
(^x.(^y.(^u.y)(^u.u)))
(^x.(^y.y))
expresson reduce:AO
(^n.(^x.(^y.n(^g.(^h.h(gx)))(^u.y)(^u.u))))(^x.(^y.xy))
(^x.(^y.(^x.(^y.xy))(^g.(^h.h(gx)))(^u.y)(^u.u)))
(^x.(^y.(^y.(^g.(^h.h(gx)))y)(^u.y)(^u.u)))
(^x.(^y.(^g.(^h.h(gx)))(^u.y)(^u.u)))
(^x.(^y.(^h.h((^u.y)x))(^u.u)))
(^x.(^y.(^u.u)((^u.y)x)))
(^x.(^y.((^u.y)x)))
(^x.(^y.y))
expresson reduce:DXYZ
(^x.(^y.(^z.z((^x.(^y.x))y)x)))XY(^x.(^y.y))
(^y.(^z.z((^x.(^y.x))y)X))Y(^x.(^y.y))
(^z.z((^x.(^y.x))Y)X)(^x.(^y.y))
(^x.(^y.y))((^x.(^y.x))Y)X
(^y.y)X
X
expresson reduce:DXYO
(^x.(^y.(^z.z((^x.(^y.x))y)x)))XY(^x.(^y.xy))
(^y.(^z.z((^x.(^y.x))y)X))Y(^x.(^y.xy))
(^z.z((^x.(^y.x))Y)X)(^x.(^y.xy))
(^x.(^y.xy))((^x.(^y.x))Y)X
(^y.((^x.(^y.x))Y)y)X
((^x.(^y.x))Y)X
(^y.Y)X
Y
expresson reduce:DXYT
(^x.(^y.(^z.z((^x.(^y.x))y)x)))XY(^x.(^y.(x(x(xy)))))
(^y.(^z.z((^x.(^y.x))y)X))Y(^x.(^y.(x(x(xy)))))
(^z.z((^x.(^y.x))Y)X)(^x.(^y.(x(x(xy)))))
(^x.(^y.(x(x(xy)))))((^x.(^y.x))Y)X
(^y.(((^x.(^y.x))Y)(((^x.(^y.x))Y)(((^x.(^y.x))Y)y))))X
(((^x.(^y.x))Y)(((^x.(^y.x))Y)(((^x.(^y.x))Y)X)))
((^y.Y)(((^x.(^y.x))Y)(((^x.(^y.x))Y)X)))
Y

递归 Y组合子的应用

递归表达式：

Rxyz = Dx(yz(Rxy(Az)))z.

A是减一，D是条件表达式，z是church n ，如果z等于0，返回x，如果z不等于0，返回yz(Rxy(Az))，对y进行调用，参数是z 和 Rxy(Az)。
举例：如果y是加法，x等于church 0，z是church n，Rxyz返回的是z + z-1 + z-2 + z-3 ... + 0

根据Yx = x(Yx) 可以得到当对Y调用x的时候，返回x(Yx)，即应用(Yx)到x上，如果x是一个多参数的函数（大于一个参数），那么Yx调用执行后x(Yx)，传递给x的第一个参数(Yx)继续代表最开始的Yx调用本身。简单例子如下：

X = (λf. λn. n==0 ? 1 : n*(f n-1))
(YX)4
-> Y (λf. λn. n==0 ? 1 : n*(f n-1))  4
-> X(YX)4 两个参数：代入X，f = (YX)，n = 4
-> 4 * ((YX) 3)
...
-> 4 * 3 * 2 * 1 * ((YX 0))

对R应用Yx，得到如下：

Rxyz = Dx(yz(Rxy(Az)))z.
R' = Y(^uxyz.Dx(yz(uxy(Az)))z)

R有三个参数，应该再增加一个参数u，放在第一个位置，代表R本身即(Yx),将R内的R替换成u，即可。
Y(^uxyz.Dx(yz(uxy(Az)))z)ZPF，xyz赋值为 church 0，加法，church 4，计算的结果应该是4+3+2+1+0=10

java -jar ./lambda-1.0-SNAPSHOT.jar d:\github\essential-Lambda\yapply.txt

expresson reduce:Y(^uxyz.Dx(yz(uxy(Az)))z)ZPF
(^x.(^y.x(yy))(^y.x(yy)))(^u.(^x.(^y.(^z.(^x.(^y.(^z.z((^x.(^y.x))y)x)))x(yz(uxy((^n.(^x.(^y.n(^g.(^h.h(gx)))(^u.y)(^u.u))))z)))z))))(^x.(^y.y))(^m.(^n.(^x.(^y.mx(nxy)))))(^x.(^y.(x(x(x(xy))))))
(^y.(^u.(^x.(^y.(^z.(^x.(^y.(^z.z((^x.(^y.x))y)x)))x(yz(uxy((^n.(^x.(^y.n(^g.(^h.h(gx)))(^u.y)(^u.u))))z)))z))))(yy))(^y.(^u.(^x.(^y.(^z.(^x.(^y.(^z.z((^x.(^y.x))y)x)))x(yz(uxy((^n.(^x.(^y.n(^g.(^h.h(gx)))(^u.y)(^u.u))))z)))z))))(yy))(^x.(^y.y))(^m.(^n.(^x.(^y.mx(nxy)))))(^x.(^y.(x(x(x(xy))))))
.........
.........
(^x.(^y.(x(x(x(x(x(x(x(x(x(x((^x.(^y.y))xy)))))))))))))
(^x.(^y.(x(x(x(x(x(x(x(x(x(x((^y.y)y)))))))))))))
(^x.(^y.(x(x(x(x(x(x(x(x(x(xy))))))))))))

不可判定性 undecidable

罗素悖论

罗素悖论指的是由罗素发现的一个集合论悖论。设集合S是由一切不属于自身的集合所组成，即“S={x|x ∉ x}”。那么问题是：S包含于S是否成立？首先，若S包含于S，则不符合x∉x，则S不包含于S；其次，若S不包含于S，则符合x∉x，S包含于S。

要证明不可判定性，就要在被判定的语句中形成一条罗素悖论，这条语句否定了它本身的被判定的结果。假设判定过程为F，判定语句为J：

J = 如果F(J)为真，那么我返回假；F(J)为假，我返回真

这样一条语句，就形成了罗素悖论，如果F(J)返回为真，判定J为真，但是J本身又推导出自己为假；如果F(J)返回为假，判定J为假，J又推导出自己为真。从而形成不可判定。

哥德尔数

但是J语句本身是无法表示的，因为用F去判定J的时候，又引用到了F对J的判定结果，会形成死循环，导致无法结束。所以引入自然数，作为载体，将语句编码成自然数，然后F判定的时候输入自然数，然后解码为原来的语句，再进行判定。

自然数可以表示从0到无穷大，总有一个自然数表示的是J的编码，再或者可以通过数的加减乘除得到J的自然数编码，至少提供了一个构造的方向。这个编码的过程最早由哥德尔引入，语句编码出的数，称为哥德尔数。使用gd(X)表示对X语句进行哥德尔编码得到的自然数。

哥德尔数通过对字符分配一个素数，比如 (λx.y)，分别给'(', 'λ', 'x', '.', 'y', ')' 这六个符号分配2,3,5,7,11,13，(λx.y)语句得到的数值就是235711*13，然后对这个数值进行素数分解，得到的素数列表转换成字符列表就是原始的语句。

丘奇数

自然数在lambda语义中，可以使用丘奇数来表达，所以除了语句和哥德尔数之前的转换之外，在lambda语义中，哥德尔数（自然数）要转为丘奇数进行表示。

n的church number 表示为，指的是自然数n在lambda中表示为函数形式。例如5表示为(λxy.x(x(x(x(xy)))))

将语句编码为哥德尔数的时候，存在两个关于自然数的函数：

输入的是两个自然数，对自然数进行哥德尔反编码，得到语句，对两个语句执行apply，得到一个新的语句，然后进行哥德尔编码得到对应的新语句的自然数。

输入自然数，首先将改自然数转换成丘奇数，得到数的函数表达语句，然后对该语句再进行哥德尔编码，得到对应的自然数。

因为自然数在lambda中使用丘奇数的函数形式表示，引入一个方便的符号表达：，对于λ-term X，对应的X的哥德尔数的丘奇数表示记为

即先对X语句求其哥德尔编码后的自然数，然后再将该自然数数值，转成丘奇数的函数形式。

和两个关于自然数的函数，在lambda中分别表示为：

函数的意义是一样的，只是采用了lambda的丘奇数来表示自然数，将输入和输出的参数改变了表示方式。

closed under conversion

一对自然数的集合被称为recursively separable，当且仅当有一个完全递归函数，输出只有0和1：

一对包含λ-terms的集合，被称为recursively separable，当且仅当对将集合内的terms编码成哥德尔数之和形成的两个自然数的集合是recursively separable。

一个集合，包含自然数或者λ-terms，称为recursive或者decidable，当且仅当该集合和它的补给是recursively separable。

非正式地讲，如果一对集合是recursively separable，当且仅当的交集为空，并且有一个算法能够判定一个数字或者λ-term在内，还是内。

在lambda内，一个包含λ-terms的集合被称为 closed under conversion，当且仅当对于所有的terms X，Y，

Scott–Curry undecidability theorem

For sets of terms in λ with =β: no pair of non-empty sets which are closed under conversion is recursively separable.

对于由 =β 形成的λ-terms的集合，没有一对非空的closed under conversion 集合，是recursively separable。即存在一个λ-term无法判定他是属于集合A还是集合B的。

针对自然数有：

让集合包含λ-terms，则：

在lambda中使用F来表示，则

我们构造一个悖论λ-term J，选择任何一个term

如果能构造J 就证明了不可判定性。

J如下：

D是前面提到的条件组合子，

如何构造J呢？y 不属于 AB的自由变量的集合

T和N都是之前定义的：

通过成功构造J，H语句和它的哥德尔数是可以准确计算的，所以J可以成功得到，形成悖论。