【🤦‍♂️工作无用】证明 JS 和 TS 类型编程是图灵完备的

avatar
前端工程师 @公众号：ELab团队

如何证明

图灵完备和实现偏递归函数是等价的，关于偏递归函数的定义可以参照以下系列视频，我觉得这几个视频介绍偏递归函数解释得比较简单明了。

  1. Partial Recursive Functions 1: What's a function?
  2. Partial Recursive Functions 2: The basic functions
  3. Partial Recursive Functions 3: Composition
  4. Partial Recursive Functions 4: Primitive Recursion
  5. Partial Recursive Functions 5: Minimisation

由于视频存放于油管，感兴趣的同学可以自行搜索哈~。

因为图灵完备和实现偏递归函数是等价的 ，因为我们可以通过用一门语言实现偏递归函数来证明这门语言是图灵完备完备的。这种领域有一个有趣的定理是，任意偏递归函数都可以由原始递归函数经过一次极小化得来，所以写程序的时候如果发现两层以上的无限循环要格外小心，很可能逻辑是错的。

偏递归函数的定义

在偏递归函数这个领域有三个基本函数和三个基本操作，三个基本函数为零函数、后继函数和投影函数，三个基本操作为组合、原始递归和最小化。所有的可计算问题可以由这三个基本函数和基本操作组合而来，由原始递归操作得到的函数叫原始递归函数，将原始递归函数进行最小化后得到的函数称为偏递归函数。

函数

这里对函数定义是一个或者多个非负整数到单个非负整数的映射，非负整数集我们用 N\mathbb {N} 来表示，如果这个这个函数接受 nn 个参数，则记作 Nn→N\mathbb {N}^n\rightarrow\mathbb {N}。当函数对所有输入都有输出的时候，则称函数是完全的（total），用符号 →\rightarrow 来表示，否则称其为非完全（partial），用符号 ⇀\rightharpoonup 来表示。

基本函数

零函数/zero

基本定义

Zero(a1,a2,...,an)=0:Nn→0Zero(a_1, a_2, ..., a_n) = 0: \mathbb {N}^n\rightarrow0

nn 个参数的零函数我们简单记作 ZeronZero^n

形象化记忆

可以理解为在某个内存地址，将地址内容置空为 0。

后继函数/Successor

基本定义

Succ(n)=n+1:N→NSucc(n) = n+1: \mathbb {N}\rightarrow\mathbb {N}

形象化记忆

可以理解为在某个内存地址，将地址内容进行 +1 操作，能够实现一个加法器。

投影/Projection

基本定义

Proj(a1,a2,...,ai,...,an)=ai:Nn→NProj(a_1, a_2, ..., a_i, ..., a_n) = a_i:\mathbb {N}^n\rightarrow\mathbb {N}

具有 nn 个参数的投影函数返回第 ii 个参数，我们简单地记作 ProjinProj^n_i。

形象化记忆

可以理解为对内存的某个地址进行取值。

基本操作

组合/Composition

基本定义

给定 mm 个函数 g1(a1,a2,...,an),...,gm(a1,a2,...,an)g_1(a_1, a_2, ..., a_n), ..., g_m(a_1, a_2, ..., a_n) 和函数 h(a1,a2,....,am)h(a_1, a_2, ...., a_m)，定义 f(a1,a2,...,an)=h(g1(a1,a2,...,an),...,gm(a1,a2,...,an))f(a_1, a_2, ..., a_n) = h(g_1(a_1, a_2, ..., a_n), ..., g_m(a_1, a_2, ..., a_n))，则称 ff 为 hh 和 g1,g2,...,gmg_1, g_2, ..., g_m 的组合操作，记作 f=h∘[g1,g2,...,gm]f=h\circ[g_1, g_2, ..., g_m]。

形象化记忆

可以理解为支持函数调用/复合函数。

原始递归

基本定义

给定函数 gg 和函数 hh，如果满足以下条件，定义函数 ff 为 gg 和 hh 的原始递归操作，记作 f=ρ(g,h)f=\rho(g, h)：

base case:

f(x1,x2,...,xn,0)=g(x1,x2,...,xn)f(x_1, x_2, ..., x_n, 0)=g(x_1, x_2, ..., x_n)

recursive case:

f(x1,x2,...,xn,y+1)=h(x1,x2,...,xn,y,f(x1,x2,...,xn,y))f(x_1, x_2, ..., x_n, y+1)=h(x_1, x_2, ..., x_n, y, f(x_1, x_2, ..., x_n, y))

形象化记忆

可以理解为支持递归。

最小化

给定函数 f(x1,x2,...,xn,i)≥0f(x_1, x_2, ..., x_n, i)\ge0，最小化 μ(f)(x1,x2,...,xn,i)\mu(f)(x_1, x_2, ..., x_n, i) 定义为找到第一个 zz 使得 f(x1,x2,...,xn,z)=0f(x_1, x_2, ..., x_n, z)=0。

原始递归函数由最小化得到的函数叫偏递归函数。

形象化记忆

可以理解为可以实现 while 循环。

偏递归函数的作用

计算机上面任何可计算的问题都可以用上面的基本函数和基本操作来组合实现，下面举几个例子：

加法

首先先说结论，加法可以用原始递归操作实现。首先我们的加法是 add(x,y)add(x,y) 是一个 N2→N\mathbb {N}^2\rightarrow\mathbb {N} 的函数，也就是我们需要找函数 gg 是 N1→N\mathbb {N}^1\rightarrow\mathbb {N} 的函数，hh 是 N3→N\mathbb {N}^3\rightarrow\mathbb {N} 的函数，如果用原始递归的话：

Base Case:

add(x,0)=x+0=xadd(x,0)=x+0=x，也就是 gg 是 Proj12Proj^2_1。

Recursive Case:

add(x,y+1)=h(x,y,add(x,y))=succ(add(x,y))add(x,y+1)=h(x,y,add(x,y))=succ(add(x,y))，也就是 h=succ∘[Proj33]h=succ\circ[Proj^3_3]。

总结上面得到的 gg 和 hh，也就是 add(x,y)=ρ(Proj12,succ∘[Proj33])add(x,y)=\rho(Proj^2_1, succ\circ[Proj^3_3])，可以看到，加法可以通过三种基本函数和三种基本操作组成。

前继函数

也可以用原始递归实现

pred(x)=x−1pred(x)=x-1

Base Case:

pred(0)=g()=0pred(0)=g()=0，也就是 gg 是 zero0zero^0。

Recursive Case:

pred(x+1)=h(x,pred(x))=x=Proj12pred(x+1)=h(x,pred(x))=x=Proj^2_1，也就是 h=Proj12h=Proj^2_1。

总结上面得到的 gg 和 hh，也就是 pred(x)=ρ(zero0,Proj12)pred(x)=\rho(zero^0, Proj^2_1)。

减法

也可以用原始递归实现

sub(x,y)=x−ysub(x, y) = x -y

Base Case:

sub(x,0)=x−0=xsub(x, 0)=x-0=x，也就是 gg 是 Proj12Proj^2_1。

Recursive Case:

sub(x,y+1)=h(x,y,sub(x,y))=pred(sub(x,y))sub(x, y + 1)=h(x, y, sub(x, y))=pred(sub(x,y))，也就是 h=pred∘Proj33h=pred\circ Proj^3_3。

总结上面得到的 gg 和 hh，也就是 sub(x,y)=ρ(Proj12,ρ(zero0,Proj12)∘Proj33)sub(x, y)=\rho(Proj^2_1, \rho(zero^0, Proj^2_1)\circ Proj^3_3)。

是否为 0/isZero

首先先说结论，isZero 可以用原始递归实现，首先给出 isZeroisZero 的定义：

isZero(x)={0ifx=0 1ifx>0isZero(x)=\left\{ \begin{aligned} 0 && if && x = 0\\\ 1 && if && x > 0 \end{aligned} \right.

也就是 isZero(0)=0isZero(0) = 0，isZero(x+1)=1isZero(x+1)=1。所以我们可以得出

Base Case:

isZero(0)=0isZero(0) = 0，也就是 gg 是 Zero1Zero^1。

Recursive Case:

isZero(x+1)=Succ(Zero1)=h(x,isZero(x))isZero(x+1)= Succ(Zero^1) = h(x, isZero(x)) ，也就是 h=succ∘[Zero1∘[Proj2_1]]h=succ\circ[Zero^1\circ[Proj^2\_1]]。

总结上面得到的 gg 和 hh，也就是 isZero(x,y)=ρ(Zero1,succ∘[Zero1∘[Proj12]])isZero(x,y)=\rho(Zero^1, succ\circ[Zero^1\circ[Proj^2_1]])，可以看到，加法可以通过三种基本函数和三种基本操作组成。

<=/小于等于/isLessEqualThan

先给出定义：

isLessThan(x,y)={0ifx−y<=0 1ifx−y>0isLessThan(x, y)=\left\{ \begin{aligned} 0 && if && x - y <= 0 \\\ 1 && if && x - y > 0 \end{aligned} \right.

这里比较清晰了，我们只要复用一下 subsub 就可以

isLessThan(x,y)=isZero∘[sub]isLessThan(x,y)=isZero\circ[sub]

乘法

Base Case:

mul(x,0)=0mul(x, 0) = 0，也就是 gg 是 Zero1Zero^1。

Recursive Case:

mul(x,y+1)=add(x,mul(x,y))=h(x,y,mul(x,y))mul(x, y+1)=add(x, mul(x, y))=h(x, y, mul(x, y))，也就是 h=add∘[Proj13,Proj33]h=add\circ[Proj^3_1, Proj^3_3]。

除法

首先先说结论，除法可以用最小化实现。对于两个非负整数 N\mathbb {N}，且 a>ba>b，则定义：

f(a,b,q)={1if(q+1)b<=a 0if(q+1)b>af(a, b, q)=\left\{ \begin{aligned} 1 && if && (q+1)b <= a \\\ 0 && if && (q+1)b > a \end{aligned} \right.

这里先写结论，后续证明看后面的 JS 代码实现处可以比较直观地看到。

f(a,b,q)=isLessThan∘[mul∘[succ∘[Proj33],Proj23],Proj13]f(a, b, q)=isLessThan\circ[mul\circ[succ\circ [Proj^3_3], Proj^3_2] , Proj^3_1]，div(x,y)=μ2fdiv(x,y)= \mu^2f

JS 是图灵完备的

我们先来简单的，证明 JS 是图灵完备的。

// 基本函数
//// 零函数
function zero(...args) {
  return 0;
}
//// 后继函数
function succ(n) {
  return n + 1;
}
//// 投影函数
function getProjFunc(n) {
  return (...args) => args[n];
}
const projN1 = getProjFunc(1);
//// ...
// 基本操作
//// 组合
function compose(h, ...funcs) {
  return function (...args) {
    return h(...funcs.map((f) => f(...args)));
  };
}
//// 原始递归
function primitiveRecursion(g, h) {
  return function __primitiveRecursion(n, ...args) {
    if (0 === n) {
      let resp = g(...args);
      // console.log("0 resp", resp, n, args);
      return resp;
    }
    let last = __primitiveRecursion(n - 1, ...args);
    let resp = h(n - 1, last, ...args);
    // console.log("n resp", resp, n, args);
    return resp;
  };
}
//// 最小化
function getMinimizationFunction(f) {
  return function (...args) {
    let i = 0;
    while (i < Number.POSITIVE_INFINITY) {
      if (f(i, ...args) === 0) {
        return i;
      }
      i++;
    }
    return undefined;
  };
}
// 加法
/*
      这里注意投影函数和前面公式推导不一样了，是因为我们过程中一些函数的参数位置与推导处不一样，但是本质是一样的
  */
const add = primitiveRecursion(getProjFunc(0), compose(succ, getProjFunc(1)));
const pred = primitiveRecursion(zero, getProjFunc(0));
const sub = primitiveRecursion(getProjFunc(0), compose(pred, getProjFunc(1)));
const isZero = primitiveRecursion(
  zero,
  compose(succ, compose(zero, getProjFunc(0)))
);
const isLessThan = compose(isZero, sub);
const mul = primitiveRecursion(
  zero,
  compose(add, getProjFunc(1), getProjFunc(2))
);
// div 的推导过程
// const f = (i, a, b) => {
//   if ((i + 1) * b <= a) {
//     return 1;
//   }
//   return 0;
// }
// 第二步
// const f = compose(isLessThan, (i, a, b) => {
//   return (i + 1) * b;
// }, getProjFunc(1));
// const div = getMinimizationFunction(f);
const div = getMinimizationFunction(
  compose(
    isLessThan,
    compose(mul, compose(succ, getProjFunc(0)), getProjFunc(2)),
    getProjFunc(1)
  )
);
console.log(add(3, 4)); // 7
console.log(pred(1), pred(2), pred(0)); // 0, 1, 0
// 这里其实是 3 - 1, 3 - 2, 3 - 3, 3 - 4
console.log(sub(1, 3), sub(2, 3), sub(3, 3), sub(4, 3)); // 2, 1, 0, 0
console.log(isZero(0), isZero(3)); // 0, 1
// 4 <= 3, 3 <= 4, 2 <= 4
console.log(isLessThan(3, 4), isLessThan(4, 3), isLessThan(4, 2)); // 1, 0, 0
// 3 * 4
console.log(mul(3, 4)); // 12
// 6 / 4
console.log(div(6, 4)); // 1

TS 类型编程是图灵完备的

这个估计稍稍有点复杂，我试一下 😅。

// 基本函数
//// 零函数
/*
    type Zero<A, B, C, D, E, F, G, ...> = 0;
*/
type Zero<A, B, C, D, E, F, G> = 0;
//// 后继函数
/*
    这个有点难，要通过一些 Trick
*/
type IntSeq<N, S extends any[] = []> = S["length"] extends N
  ? S
  : IntSeq<N, [...S, S["length"]]>;
type Succ<N> = [...IntSeq<N>, 1]["length"];
//// 投影函数
/*
    我们可以直接写特定的投影函数
*/
type Proj31<A, B, C> = A;
//// ...
// 基本操作
//// 组合
/*
    这个比较简单，我们可以直接写出组合
*/
type H<A, B, C> = 0;
type G<A, B, C> = 0;
type ComposedType<A, B, C> = H<G<A, B, C>, G<A, B, C>, G<A, B, C>>;
//// 原始递归
/*
    递归的话我们先实现一下减一函数会比较方便
*/
type Pop<T extends any[]> = T extends [...(infer I), infer _] ? I : never;
type Pred<N> = Pop<[...IntSeq<N>]>["length"];
type PG<A, B, C> = 0;
type HG<N, Y, A, B, C> = 0;
type PremitiveFunc<N, A, B, C> = N extends 0
  ? PG<A, B, C>
  : HG<N, PremitiveFunc<Pred<N>, A, B, C>, A, B, C>;
//// 最小化
/*
    有递归比较好办，我们直接用递归来实现
*/
type MF<A, B, C, I> = 0;
type Miminize<A, B, C, I> = MF<A, B, C, I> extends 0 ? I : Miminize<A, B, C, Succ<I>>;
type Miminized<A, B, C> = Miminize<A, B, C, 0>;
// 加法
/*
    这里注意投影函数和前面公式推导不一样了，是因为我们过程中一些函数的参数位置与推导处不一样，但是本质是一样的
*/
type Proj11<A> = A;
type Proj32<A, B, C> = B;
type SuccComposedProj<A, B, C> = Succ<Proj32<A, B, C>>;
type Add<X, Y> = Y extends 0 ? Proj11<X> : SuccComposedProj<X, Add<X, Pred<Y>>, Y>;
type R = Add<3, 4>; // 7
// 剩下的写起来比较繁琐，基本思路请按照 JS 的证明

❤️ 谢谢支持

  1. 喜欢的话别忘了 分享、点赞、在看 三连哦~。
avatar
文章
阅读
粉丝
相关推荐
又一个全新编程语言，诞生了！
86k阅读
 · 
685点赞
27岁程序媛未来的出路到底在哪里？
222k阅读
 · 
1.9k点赞
前端中 JS 发起的请求可以暂停吗？
46k阅读
 · 
429点赞
我是怎么在掘金找到老婆的
157k阅读
 · 
3.1k点赞
🌝 重学 TS
74k阅读
 · 
1.6k点赞
基于 ChatGPT 和 React 搭建 JSON 转 TS 的 Web 应用
254k阅读
 · 
214点赞
JS 判断数据类型的 8 种方式
18k阅读
 · 
159点赞
年后被吊打的第一面
252k阅读
 · 
3.3k点赞
项目中 2 个真实的 TS 类型编程案例
6.9k阅读
 · 
80点赞
JS Promise 101：Promise基础
43k阅读
 · 
274点赞

友情链接：