docs: add TCS lec06-lec09

Author: Xecades

docs/config.yml

@@ -6,6 +6,10 @@ nav:
                 - lec03
                 - lec04
                 - lec05
+                - lec06
+                - lec07
+                - lec08
+                - lec09
           - rl:
                 - fundamentals
                 - value-based

docs/cs/tcs/assets/lec07-pda-example.png

@@ -72,6 +72,6 @@ DFA 转 NFA 是显然的，考虑 NFA 转 DFA。
 :::fold{title="证明" expand}
 只需证明 NFA 和正则表达式等等价。右到左显然，考虑左到右。
 
-略。
+略（在 Lec06 讲的，直觉上是通过删 node 实现，理论上是一个 DP 过程，没有详细记笔记，期末记得看一下视频）。
 :::
 ::

docs/cs/tcs/assets/lec08-tm.png

@@ -0,0 +1,41 @@
+---
+title: Lecture 06
+---
+
+## Pumping Theorem
+
+::fold{title="**泵引理**：正则表达式的必要条件" success always expand}
+若语言 $L$ 是正则的，则存在一个整数 $p \geqslant 1$（称为 **Pumping length**），使得对任意字符串 $w \in L$，只要 $|w| \geqslant p$，就可以将 $w$ 分解为 $w = xyz$，满足：
+
+1.  对任意 $i \geqslant 0$，字符串 $xy^iz \in L$；
+2.  $|y| > 0$；
+3.  $|xy| \leqslant p$。
+
+:::fold{title="证明" expand}
+设 $M = (K, s, F, \delta)$ 是一个接受 $L$ 的 DFA，令 $p = |K|$（**State 数**）。对任意 $w \in L$，且 $|w| \geqslant p$，考虑 $M$ 处理 $w$ 的过程：
+
+由于 $|w| \geqslant p$，根据抽屉原理，在处理前 $p$ 个字符时，**$M$ 一定会访问某个状态两次**。设这两个位置分别为 $j$ 和 $k$，其中 $0 \leqslant j < k \leqslant p$。
+
+将 $w$ 分解为 $w = xyz$，其中：
+
+-   $x$ 是 $w$ 的前 $j$ 个字符；
+-   $y$ 是从位置 $j$ 到 $k$ 的字符；
+-   $z$ 是剩余的字符。
+
+由于 $M$ 在处理 $y$ 时从状态 $q$ 回到状态 $q$，因此对于任意 $i \geqslant 0$，字符串 $xy^iz$ 也会被 $M$ 接受。
+
+此外，$|y| = k - j > 0$，且 $|xy| = k \leqslant p$。
+:::
+
+:::fold{title="例题" info expand}
+_Use pumping theorem to show that $L=\{ww : w\in\{0, 1\}^*\}$ is not regular._
+
+假设 $L$ 是正则的，则存在一个整数 $p \geqslant 1$ 满足泵引理。
+
+选择字符串 $s = 0^p1^p0^p1^p \in L$，显然 $|s| = 4p > p$。根据泵引理，$s$ 可以被分解为 $s = xyz$，满足上述三个条件。由于 $|xy| \leqslant p$，所以 $y$ 只能包含字符 '0'。设 $y = 0^k$，其中 $k > 0$。根据泵引理，对任意 $i \geqslant 0$，字符串 $xy^iz \in L$。选择 $i = 2$，则有：
+
+$$xy^2z = 0^{p+k}1^p0^p1^p$$
+
+显然，$xy^2z \notin L$，因为它不再是形如 $ww$ 的字符串。这与假设 $L$ 是正则的矛盾。因此，语言 $L = \{ww : w\in\{0, 1\}^*\}$ 不是正则的。
+:::
+::

docs/cs/tcs/lec05.md

@@ -0,0 +1,124 @@
+---
+title: Lecture 07
+---
+
+之前学的 DFA、NFA、RegExp 的表达能力等价，都很有限，甚至无法表达一些简单的语言，比如 $\{0^n1^n \mid n \geqslant 0\}$。因此本节课尝试对其扩展。
+
+## Pushdown Automaton (PDA)
+
+**PDA = DFA + Stack**（额外加了内存部分）。
+
+**PDA**：$P = (K, \Delta, s, F)$，其中
+
+-   $K$、$s$、$F$ 同 DFA；
+-   $\Delta$ 仍然是转移函数，但变成了 $(K\times\{0,1,e\}\times\{0,1\}^*)\times(K\times\{0,1\}^*)$ 的**有限子集**。其中：
+    -   $K$：当前状态
+    -   $\{0,1,e\}$：当前读入的非确定性 symbol（和 NFA 一致）
+    -   $\{0,1\}^*$：从当前栈顶 pop 出来的串
+    -   $K$：下一个状态
+    -   $\{0,1\}^*$：push 进栈的串
+-   e.g. $((p,0,110),(q,01))$：如果当前状态为 p，读到 0，且栈顶为 110，则转移到状态 q，并将栈顶的 110 pop 出，push 入 01。
+    ![$((p,0,110),(q,01))$，执行过程可理解为纸带+读写头](./assets/lec07-pda-example.png)
+
+---
+
+**配置（Configuration）**：三元组 $(p, x, \alpha) \in K \times \{0,1\}^* \times \{0,1\}^*$，表示当前状态为 $p$，纸带**剩余**输入串为 $x$（因为之前读入的已经不会影响后续结果了），栈内容为 $\alpha$。
+
+**Yield in one step**：$(p, x, \alpha) \vdash_P (q, y, \beta)$，表示从配置 $(p, x, \alpha)$ 可以通过**一次转移**到达配置 $(q, y, \beta)$，下标 $P$ 表示 PDA。符号 $\vdash_P$ 读作“yields in one step”。
+
+**Yield**：$\vdash_P^*$ 为 $\vdash_P$ 的闭包，表示通过**若干次转移**可以从一个配置到达另一个配置。读作“yields”。
+
+**$P$ accepts $w\in\{0,1\}^*$, if $(s, w, e) \vdash_P^* (f, e, e)$ for some $f \in F$.** 即从初始配置 $(s, w, e)$ 出发，经过若干次转移，可以到达某个接受状态 $f$，且此时纸带和栈均清空。
+
+**Language of $P$** $L(P)$ 为被 $P$ 接受的所有字符串的集合。称 $P$ **decides** $L(P)$。如果语言 $L$ 能被某台 PDA 判定，则称 $L$ 为**上下文无关语言（Context-Free Language, CFL）**。
+
+::fold{title="例题" info always expand}
+
+1. 设计 PDA 接受语言 $L = \{w\in\{0,1\}^* \mid \text{\#0's = \#1's in } w\}$（即 0 和 1 个数相同）。  
+   $K = \{q\}$，$s = q$，$F = \{q\}$，$\Delta$ 包含以下转移：
+    - $((q,0,e), (q,0))$：读到 0，不管栈顶是什么，都 push 入 0；
+    - $((q,0,1), (q,e))$：读到 0，栈顶为 1，则 pop 出 1（PDA 和 NFA 类似，也能去“猜”，所以和上一条不矛盾）；
+    - $((q,1,e), (q,1))$：读到 1，不管栈顶是什么，都 push 入 1；
+    - $((q,1,0), (q,e))$：读到 1，栈顶为 0，则 pop 出 0。
+2. 设计 PDA 接受语言 $L = \{ww^\text{Reverse} \mid w\in\{0,1\}^*\}$（即任意串拼上其逆序串）。  
+   $K = \{l, r\}$，$s = l$，$F = \{r\}$，$\Delta$ 包含以下转移：
+    - $((l,0,e), (l,0))$：读到 0，不管栈顶是什么，都 push 入 0；
+    - $((l,1,e), (l,1))$：读到 1，不管栈顶是什么，都 push 入 1；
+    - $((l,e,e), (r,e))$：通过 $e$-transition 转移到状态 $r$；
+    - $((r,0,0), (r,e))$：读到 0，栈顶为 0，则 pop 出 0；
+    - $((r,1,1), (r,e))$：读到 1，栈顶为 1，则 pop 出 1。
+
+::
+
+---
+
+之前研究的 DFA、NFA、PDA 都属于 **Language Recognizer**，即给定一个字符串，判断其是否属于某个语言。接下来研究 **Language Generator**，即通过某种规则生成语言中的字符串。
+
+研究 **Language Generator** 的一个重要工具是 **语法（Grammar）**。
+
+## Context-Free Grammar (CFG)
+
+**CFG**：$G = (V, S, R)$，其中
+
+-   $V$：有限符号集合，包括 $\{0,1\}$。其中 $V\setminus\{0,1\}$ 中的符号称为**非终结符（Non-terminal）**，与之相对 $0,1$ 称为**终结符（Terminal）**
+-   $S \in V\setminus\{0,1\}$：Start Symbol，属于非终结符
+-   $R \subset (V \setminus \{0,1\}) \times V^*$：有限规则集合（右侧是无穷集，但是要求 $R$ 有限）
+
+---
+
+**Derive in one step**：对 $x, y, u \in V^*$，$A \in V\setminus\{0,1\}$，如果 $(A, u) \in R$，则有 $xAy \Rightarrow_G =xuy$，符号 $\Rightarrow_G$ 读作“derives in one step”。
+
+**Derive**：$\Rightarrow_G^*$ 为 $\Rightarrow_G$ 的闭包，即可以用多次规则替换。
+
+**$G$ generates $w \in \{0,1\}^*$, if $S \Rightarrow_G^* w$.** 即从 Start Symbol $S$ 出发，经过若干次规则替换，可以得到字符串 $w$。
+
+**Language of $G$** $L(G)$ 为被 $G$ 生成的所有字符串的集合。称 $G$ **generates** $L(G)$。
+
+::fold{title="例题" info always expand}
+设计 CFG 生成语言 $L = \{w\in\{0,1\}^* \mid w=w^\text{Reverse}\}$（即回文串）：
+
+$S \to e \mid 0 \mid 1 \mid 0S0 \mid 1S1$（竖线表示“或”）
+::
+
+---
+
+::fold{title="**定理**：PDA 和 CFG 等价" success always expand}
+对于语言 $L$，存在 PDA $P$ 接受 $L$ 当且仅当存在 CFG $G$ 生成 $L$。
+
+:::fold{title="证明" expand}
+**$P\Leftarrow G$：**
+
+> 思路：1. 非确定性地在栈上构造目标串；2. 读入目标串并与栈上内容相消；3. 若栈空且读完输入串，则接受。
+
+令 $G = (V, S, R)$，构造 $P = (K, \Delta, s, F)$ 如下：
+
+-   $K = \{p, q\}$，$s = p$，$F = \{q\}$；
+-   $\Delta$ 包含以下转移：
+    -   $((p,e,e), (q,S))$：初始时将 $S$ push 入栈，并转移到状态 $q$；
+    -   $((q,e,A), (q,u))$ for $\forall (A,u) \in R$：非确定性地用规则替换栈顶的非终结符 $A$ 为 $u$；
+    -   $((q,a,a), (q,e))$ for $\forall a \in \{0,1\}$：读入输入串并与栈顶内容相消；
+
+---
+
+**$P\Rightarrow G$：**
+
+> 思路：先化简 PDA，然后再构造 CFG。
+
+将 $P$ 化简为满足以下条件的 $P = (K, \Delta, s, F)$：
+
+1. 只有一个接受状态 $f$，即 $F = \{f\}$；
+2. 每次转移要么只 push，要么只 pop，而且每次只 push/pop 一个 symbol。
+
+显然任意 PDA 都可以化简为满足上述条件的 PDA。
+
+构造 CFG $G = (V, S, R)$ 如下：
+
+-   $V = \{0,1\} \cup \{A_{p,q} \mid p,q \in K\}$，其中 $A_{p,q}$ 为非终结符，表示从状态 $p$ 出发，经过若干次转移，到达状态 $q$ 且栈空的字符串集合，**我们的目标是实现 $A_{p,q} \Rightarrow_G^* w$ iff $(p, w, e) \vdash_P^* (q, e, e)$**；
+-   $S = A_{s,f}$；
+-   $R$ 包含以下规则：
+    -   **空串规则** $A_{p,p} \to e$；
+    -   **连接规则** $A_{p,q} \to A_{p,r} A_{r,q}$：过程中栈清空，则可以分成两半；
+    -   **Push-pop** $A_{p,q} \to aA_{r,s}b$，如果存在 PDA转移 $((p,a,e),(r,c))$（读入 $a$ 压入 $c$）和 $((s,b,c),(q,e))$（读入 $b$ 弹出 $c$）。
+
+:::
+::

docs/cs/tcs/lec06.md

@@ -0,0 +1,167 @@
+---
+title: Lecture 08
+---
+
+PDA 虽然拓展了 DFA/NFA 的表达能力，但其能力还是有限，例如无法表达 $\{0^n1^n0^n \mid n \geqslant 0\}$（通过 PDA 版本的 Pumping Theorem 证明，没有细讲）。一个更强大的模型是 **图灵机（Turing Machine）**。
+
+## 图灵机
+
+**图灵机（Turing Machine, TM）**：$M = (K, \Sigma, s, \delta)$，其中
+
+-   $K$、$s$ 同 DFA/PDA；
+-   $\Sigma$：有限字母表，至少包含 $\{0,1,\triangleright,\sqcup\}$，其中 $\triangleright$ 为**左端标记**，$\sqcup$ 为**空白符**；
+-   $\delta$：转移函数，$\delta: K \times \Sigma \to K \times \Sigma \times \{L, R, S, H\}$，其中
+    -   $K$：当前状态
+    -   $\Sigma$：当前读入的 symbol
+    -   $K$：下一个状态
+    -   $\Sigma$：写入的 symbol（覆盖当前格子）
+    -   $\{L, R, S, H\}$：移动方向，L 表示左移一格，R 表示右移一格，S 表示不动，H 表示停机
+
+**运算过程**：给定输入 $x=x_0x_1\cdots x_{n-1} \in \{0,1\}^*$，图灵机纸带初始内容为 $\triangleright x_0x_1\cdots x_{n-1}\sqcup\sqcup\sqcup\cdots$，读写头初始位置在 $\triangleright$ 上。
+
+![图灵机运算过程](./assets/lec08-tm.png)
+
+-   如果停机：输出 $M(x)$ 为纸带上从 $\triangleright$ 之后开始到第一个 $\sqcup$ 之前的内容；
+-   如果不停机：$M(x)$ 记为 $\bot$。
+
+A TM $M$ computes a function $f: \{0,1\}^* \to \{0,1\}^*$ if $\forall x \in \{0,1\}^*$, $M(x) = f(x)$.
+
+所有能被图灵机计算的函数称为**可计算函数（computable function）**。
+
+## NAND-TM
+
+我们先考虑更简单的模型 **NAND-TM**。
+
+**NAND-TM**（= NAND-CIRC + arrays + loops）：
+
+1.  数据类型：
+    -   **下标 $i$**：唯一的整数变量，表示下标；
+    -   **Scalars**：布尔变量；
+    -   **Arrays**：布尔数组，无限长度，所有数组共用相同的下标 $i$；
+2.  输入 $X$ 和输出 $Y$ 都是数组
+3.  程序**一定以 $\text{MODANDJUMP}(a,b)$ 指令结尾**，作用为修改 $i$ 并跳转到第一行：
+    -   如果 $a=1$ 且 $b=1$，则 $i \leftarrow i + 1$；
+    -   如果 $a=0$ 且 $b=1$，则 $i \leftarrow i - 1$；
+    -   如果 $a=1$ 且 $b=0$，则 $i \leftarrow i$；
+    -   如果 $a=0$ 且 $b=0$，则停机。
+4.  除最后一行外，其他行均为 $z = \text{NAND}(x,y)$，其中 $x,y,z$ 可以是 scalars 或 array 的第 $i$ 个元素
+5.  除 $X$ 外，所有变量初始值为 0
+
+**如何区分 $\sqcup$ 和 0？**可以创建数组 $X\text{-nonblank}$，其中 $X\text{-nonblank}[i] = 1$ 则表示 $X[i] \neq \sqcup$，否则为 0。因此传入输入 $X$ 的时候还会同时传入 $X\text{-nonblank}$，输出同理。
+
+::fold{title="**例子**：NAND-TM 实现 INC" info always expand}
+**输入：**$X=x_0x_1\cdots x_{n-1}$，表示 $\sum_{i=0}^{n-1} x_i 2^i$。
+
+**要求输出：**$Y=y_0y_1\cdots y_{n-1}y_n$，满足 $\sum_{i=0}^{n} y_i 2^i = \sum_{i=0}^{n-1} x_i 2^i + 1$。
+
+定义辅助标量 carry（表示进位），started（表示是否开始计算）。
+
+```
+carry = IF(started, carry, ONE(started))
+started = ONE(started)
+Y[i] = XOR(X[i], carry)
+carry = AND(X[i], carry)
+Y-nonblank[i] = ONE(started)
+MODANDJUMP(X-nonblank[i], X-nonblank[i])
+```
+
+上述 `IF`、`ONE`、`XOR`、`AND` 均可由 NAND 实现。
+::
+
+---
+
+::fold{title="**定理**：NAND-TM 和图灵机等价" success always expand}
+对于函数 $f: \{0,1\}^* \to \{0,1\}^*$，存在 NAND-TM 程序 $P$ 计算 $f$ 当且仅当存在图灵机 $M=(K, \Sigma, s, \delta)$ 计算 $f$。
+
+:::fold{title="证明" expand}
+**$P\Leftarrow M$：**
+
+先考虑如何编码一个图灵机。
+
+-   $K$ states $\to$ $\lceil\log|K|\rceil$ scalar variables;
+-   $\Sigma$ tape symbols $\to$ $\lceil\log|\Sigma|\rceil$ arrays;（例如 $\Sigma=\{0,1,\triangleright,\sqcup\}$，至少需要 $\log_2 4 = 2$ 个数组去编码一整个 tape）
+-   $\{L, R, S, H\}$ head movements $\to$ 2 extra scalar variables;
+-   $\delta: \{0,1\}^{\lceil\log|K|\rceil + \lceil\log|\Sigma|\rceil} \to \{0,1\}^{\lceil\log|K|\rceil + \lceil\log|\Sigma|\rceil + 2}$ 是 **finite function**，可以用 NAND-CIRC 实现，记为 P-CIRC。
+
+取出 P-CIRC 计算结果的最后两项（Head movements），传入给 `MODANDJUMP` 指令，从而完成 NAND-TM 的构造。
+
+**$P\Rightarrow M$：**
+
+（就是上面的过程反过来，这里讲得很粗略）
+
+:::
+
+::
+
+## NAND-TM 语法糖
+
+::fold{title="**GOTO** / **WHILE**" info expand}
+原理：给定原始程序：
+
+```
+1. ?1 = NAND(?1, ?1)
+2. ?2 = NAND(?2, ?2)
+...
+t. ?t = NAND(?t, ?t)
+t+1. MODANDJUMP(?, ?)
+```
+
+将其行号用变量 `line` 代替：
+
+```
+IF line == 1:
+    ?1 = NAND(?1, ?1)
+    line = 2
+IF line == 2:
+    ?2 = NAND(?2, ?2)
+    line = 3
+...
+IF line == t:
+    ?t = NAND(?t, ?t)
+    line = t+1
+IF line == t+1:
+    MODANDJUMP(?, ?)
+```
+
+只需要修改 `line` 的值，即可实现任意行号跳转，也即 **GOTO** 指令。
+
+有了 GOTO，就可以实现 **WHILE** 循环。
+
+::
+
+::fold{title="**多 index**" info expand}
+例如想访问下标 j 和 k，创建两个 one-hot array `indexJ` 和 `indexK`，其中 `indexJ[j] = 1`，`indexK[k] = 1`，其他位置均为 0。
+
+再创建一个辅助数组 `AtZero`，只在 `AtZero[0] = 1`，其他位置均为 0。
+
+每次要访问下标前，先用 WHILE 循环将 `i` 移动到 0：
+
+```
+WHILE (AtZero[i] != 1):
+    修改 MODANDJUMP 的两个参数，使 i--
+```
+
+然后再用 WHILE 循环将 `i` 移动到 j 或 k：
+
+```
+WHILE (indexJ[i] != 1):
+    修改 MODANDJUMP 的两个参数，使 i++
+```
+
+::
+
+::fold{title="**多维数组**" info expand}
+多维数组是 $\mathbb{N}^n$，是可数集，可以映射到一维数组，直接拿一维数组模拟即可。
+::
+
+## NAND-RAM 模型
+
+提供：
+
+1. Bounded integer variables;
+2. Index array access;
+3. +, -, \*, /, etc.
+
+容易证明 NAND-RAM 和 NAND-TM 等价（只给了 sketch，没细讲），而前者就是现代计算机使用的 RAM 模型。
+
+因此，**图灵机与现代计算机等价**。