《计算机程序设计艺术》第一卷 1.1 读书笔记

形式化定义算法(Algorithm)

\quad 算法是“一系列规则的集合”，这些规则产生求解问题所需的一系列操作。若要形式化定义算法，需先形式化定义计算方法(Computational method)。

计算方法(Computational method)的形式化定义

\quad 计算方法可以定义成四元组 $(Q,I,\Omega ,f)$。其中 $Q,I,\Omega$ 为集合，$f$ 为函数，且 $f:Q\to Q$。

\quad 此外 $f$是在输出状态集合 $\Omega$ 上逐点不动(Pointwise fixed)的，表示对输出状态集合中的每一个状态 $q$，都有 $f(q)=q$。

1. 限定词 pointwise ，指的是“考虑函数 $f$ 的每一个值 $f(x)$ 的性质”。
2. 这是定义，即对输出集合内的状态 $q$ 应用计算规则 $f$ 得到的还是它本身。这是因为把 $f$ 看成一种能计算答案的机器，在 $q$ 已经构成答案的情况下，在其上无论怎么重复应用规则 $f$，得到的仍然是答案 $q$。
3. 这个定义非常重要，表示如果能连续应用计算规则 $f$ ，从输入状态 $x$ 产生输出状态 $x_k$，那么 $x_k$ 是稳定的。这种情况下 $f$ 对于输入状态集 $x$ 是收敛的，最终会得到一个“稳定的”结果。

\quad $Q$ 是计算过程中的所有状态集合，$I$是计算所需的输入集合，$\Omega$是计算产生的输出集合。 $f$是计算规则。$I\subseteq Q,\Omega \subseteq Q$。

\quad 这里的 $f$ 不可以简单理解为程序设计语言里的“函数”，例如 int f(int x) { return x + 1;}；$I$ 不可以简单理解为“函数输入”，$\Omega$ 同理。
\quad 因为这里的 $Q,I,\Omega$ 都是“状态”的集合，而$f$是对这些状态作转换。

\quad 在输入集合 $I$ 中的每一个输入 $x$ 都会经过计算规则 $f$，产生一串计算序列: $x_0,x_1,x_2,x_3,\dots$，其中

$$x_0=x\text{and}\forall i\ge 0,x_{i+1}=f(x_i)$$。

\quad 如果在反复运用规则 $f$ 的情况下，能够在第 $k$ 步找到属于输出集合的状态 $x_k$，那就说这个计算序列在 $k$ 步停止。或者说计算规则 $f$ 以状态 $x$ 为输入，$x_k$为输出。这里的 $k$ 是使得 $x_k\in \Omega$ 的最小的正整数。

\quad （假设计算规则能停止）如果 $x_k\in \Omega$，那么 $x_{k+1}\in \Omega$。即， $x_{k+1}=f(x_k)=x_k$。

\quad 只有对输入集合 $I$ 中的每一个输入都能停止的计算方法才能叫算法(Algorithm)。

---

例子：在已知自然数加减法的基础之上定义乘法 $f((m,n))=(m\cdot n)$

1. 令 $Q$ 为三元组 $(m,n,a)$ 所构成的集合，其中 $m,n,a\in \mathbb{N}\cup \varnothing$ 。

   • 把 $(m,n,\varnothing )$ 称为初始状态，简记为 $(m,n)$。
   • 把 $(\varnothing ,\varnothing ,a)$ 称为输出状态，简记为 $(a)$。

2. 令 $I=\{(m,n)|m,n\in \mathbb{N}\}\subset Q$ ,

3. 令 $\Omega =\{(a)|a\in \mathbb{N}\}\subset Q$。

4. 而 $f$ 定义为如下：

   • 对初始状态作转换: $f((m,n))=f((m,n,0));$
   • 对输出状态作转换: $f((a))=(a);$
   • $$f((m,n,a))=\{\begin{array}{ll}(a),& \text{if }m=0\\ (m-1,n,a+n),& \text{otherwise}\end{array}$$

可以使用 Python3 编写一个对上面过程的模拟程序:

class State:
    def __init__(self, m, n, ans = None) -> None:
        self.m = m
        self.n = n
        self.ans = ans

    def isInitialState(self) -> bool:
        return self.m is not None and \
               self.n is not None and \
               self.ans is None
    def isFinalState(self) -> bool:
        return self.m is None and \
               self.n is None and \
               self.ans is not None
    def __str__(self) -> str:
        return f"({self.ans})"

def f(state: State):
    if state.isInitialState():
        return f(State(state.m, state.n, 0))
    elif state.isFinalState():
        return state
    else:
        if state.m == 0:
            return f(State(None, None, state.ans))
        else:
            return f(State(state.m-1, state.n, state.ans + state.n))

print(f(State(100, 100))) # 100 * 100

---

对 $f$ 和 $Q$ 的约束

\quad 为满足算法的可行性(Effectiveness)，需对 $f$ 和 $Q$ 作约束。$f$ 不能是无法实现的计算规则；$Q$ 不能包含无穷个状态，使得这种计算方法无法在物理层面实现。

…👷…