lecture2打印.ZH解释

这部分是课程讲义的封面页或者说标题页，提供了关于这堂课的基本信息。

• COMS3261: 这是课程的编号。在美国大学中，课程通常由一个四字母的学科缩写（这里是COMS，代表Computer Science，即计算机科学）和一个四位数的编号组成。这个编号通常也暗示了课程的级别，3000级别的课程通常是为本科中高年级学生设计的。
• 计算机科学理论: 这是课程的名称，明确了这门课的核心内容是关于计算机科学的理论基础。这通常包括计算模型（如自动机）、语言（如形式语言）、可计算性（什么问题是计算机能解决的）和复杂性（解决一个问题需要多少资源）等主题。
• 2026年春: 这指明了课程开设的学期。
• Mihalis Yannakakis: 这是授课教授的名字。Mihalis Yannakakis是一位在理论计算机科学领域，尤其是在计算复杂性理论、数据库理论和算法设计方面享有盛誉的著名学者。
• 讲座 2, 26/1/26: 这表示这是该学期的第二讲，授课日期是2026年1月26日。

这一部分给出了确定性有限自动机（Deterministic Finite Automaton，简称DFA）的形式化定义。这是一个数学模型，用来描述一种最简单的计算设备。它由五个关键部分组成，被称为一个五元组。

• $\mathrm{A}=\left(\mathrm{Q}, \Sigma, \delta, \mathrm{q}_{0}, \mathrm{~F}\right)$: 这是DFA的整体表示。A代表这个自动机本身，它被定义为一个包含五个元素的集合，或者说元组。这五个元素共同规定了这个自动机的行为。

• $\mathrm{Q}=$ 有限状态集合:
• Q 代表 States（状态）。一个DFA在任何时刻都必须处于且仅处于一个“状态”中。
• “有限”是这里的核心。这意味着DFA的“记忆”是有限的。它只能记住有限多种情况，每种情况对应一个状态。例如，一个DFA可以有两个状态来记住一个开关是“开”还是“关”，但它不能有无限个状态来记住一个任意大的数字。
• 把状态想象成机器内部的“配置”或“模式”。

• $\Sigma=$ 有限(输入)字母表:
• Σ (Sigma) 代表 Alphabet（字母表）。这是DFA能够读取和理解的所有可能符号的集合。
• “有限”同样很重要，意味着输入符号的种类是有限的。例如，对于二进制字符串，字母表就是 $\Sigma = \{0, 1\}$。对于英文字符，字母表可以是 $\Sigma = \{'a', 'b', ..., 'z'\}$。
• DFA一次只处理来自这个字母表的一个符号。

• $\delta=$ 转移函数:
• δ (delta) 代表 Transition Function（转移函数）。这是DFA的“程序”或“规则手册”。它告诉DFA在当前处于某个状态，并且读到一个特定的输入符号时，下一步应该进入哪个状态。
• $\delta: \mathrm{Q} \times \Sigma \rightarrow \mathrm{Q}$: 这是转移函数的数学表达。
• $\mathrm{Q} \times \Sigma$ 表示所有可能的“（当前状态，当前输入符号）”的组合对。这叫作笛卡尔积。
• $\rightarrow \mathrm{Q}$ 表示这个函数的结果（输出）是状态集合 Q 中的一个元素，即下一个状态。
• “该函数对于所有输入对 $(q, a)$ 完全且唯一地定义”：这是“确定性”的来源。
• 完全定义：意味着对于任何一个状态和任何一个输入符号，都必须有一条规则告诉它去哪里。机器不会“卡住”或“不知道怎么办”。
• 唯一定义：意味着对于任何一个状态和任何一个输入符号，只有一个确定的目标状态。机器没有选择的余地，路径是唯一的。这就是确定性的含义。

• $\mathrm{q}_{0}=$ 起始(或初始)状态:
• $q_0$ 是状态集合 Q 中的一个特殊状态。它是DFA在开始处理任何输入之前的“默认”状态。
• 任何计算都从 $q_0$ 开始。
• $q_0 \in Q$，即起始状态必须是状态集合中的一员。

• $\mathrm{F} \subseteq \mathrm{Q}$ 是接受(或最终)状态的集合:
• F 代表 Final States 或 Accepting States（接受状态）。这是状态集合 Q 的一个子集。
• 当DFA读完一整个输入字符串后，如果它恰好停在了 F 集合中的某个状态，那么我们就说这个DFA“接受”了这个字符串。
• 如果最终停在不属于 F 的状态，那么这个字符串就被“拒绝”。
• F 可以是空集（$\emptyset$），表示该DFA不接受任何字符串。
• F 也可以包含所有状态（$F=Q$），表示该DFA接受所有字符串。
• F 也可以只包含部分状态。

这一部分介绍了如何将上一节中抽象的五元组定义，用一种直观的图形方式表示出来，即转移图 (Transition Diagram)。这是一种非常有用的可视化工具。

• 转移图：带标签的边的有向图:
• 有向图 (Directed Graph)：一个由节点（或顶点）和边（或弧）组成的结构，其中每条边都有一个明确的方向，从一个节点指向另一个节点。
• 带标签的边 (Labeled Edges)：图中的每条边上都有一个或多个标签，这些标签来自输入字母表 Σ。

• 节点集合 = Q (状态集合):
• 图中的每一个节点（通常画成一个圆圈）都唯一对应DFA中的一个状态。如果你有3个状态，你的图里就有3个圆圈。

• 边：...:
• 图中的边（箭头）表示状态之间的转移。
• 如果 δ(q, a) = p，则边 q → p 标记为 a: 这句话是核心。它把转移函数 δ 的规则翻译成了图的语言。
• δ(q, a) = p 是数学规则：在状态 q 读到输入 a，转移到状态 p。
• 边 q → p 标记为 a 是图形表示：从代表状态 q 的圆圈画一个箭头指向代表状态 p 的圆圈，并在这个箭头上写上标签 a。
• (如果 δ(q, a) = p 对应许多符号 a，则我们通常画一条边并放置多个标签，而不是画许多平行边)：这是一个绘图惯例，为了让图更简洁。例如，如果 $\delta(q, 'a') = p$ 并且 $\delta(q, 'b') = p$，你可以从 q 到 p 只画一个箭头，然后标上 'a', 'b'。

• '起始' 箭头指向起始状态 $q_0$:
• 为了在图中明确哪个是起始状态，我们通常会画一个没有起点的箭头指向它。这个箭头通常标有 "start" 或者就是凭空出现。

• 接受状态 (F) 用双圆圈标记:
• 为了区分接受状态和非接受状态，所有属于集合 F 的状态对应的节点，都会被画成两个同心圆（双圆圈）。普通状态只有一个圆圈。

• 图片分析:
• 图片展示了一个具体的转移图。
• 有四个节点，代表四个状态，标记为 0, 1, 2, 3。所以 $Q=\{0, 1, 2, 3\}$。
• 有一个起始箭头指向状态 0，所以 $q_0=0$。
• 状态 3 是双圆圈，所以 $F=\{3\}$。
• 边和标签定义了转移函数。例如：
• 从状态 0 出发，有一条标着 "ins" 的边指向状态 1，这意味着 $\delta(0, \text{ins})=1$。
• 从状态 1 出发，有一条标着 "del" 的边指回状态 0，这意味着 $\delta(1, \text{del})=0$。
• 在状态 3，标着 "ins" 的边指向自己，这意味着 $\delta(3, \text{ins})=3$。
• 输入字母表是边上所有标签的集合，即 $\Sigma=\{\text{ins}, \text{del}\}$。

这一部分介绍了表示DFA的第三种方法：转移表 (Transition Table)。如果说转移图是可视化的表示，那么转移表就是一种结构化、适合计算机处理的文本表示。

• 行对应状态，列对应输入符号: 表格的每一行代表一个状态，每一列代表字母表中的一个输入符号。
• q, a 的条目是 δ(q, a): 在表格的单元格中，位于状态 $q$ 所在行和符号 $a$ 所在列的交叉点，填写的值就是转移函数 $\delta(q, a)$ 的结果，即下一个状态。这本质上就是把转移函数的所有输入输出对列在一个二维数组里。
• 起始状态用 → 标记: 为了指明哪个是起始状态，通常会在该状态所在行的行首加上一个箭头 "→"。
• 接受状态用 标记: 为了指明哪些是接受状态，通常会在这些状态的名称前加上一个星号 ""。

• 表格分析:
• 该表格描述了与上一节转移图完全相同的DFA。
• 状态 (行): 表格的第一列列出了所有状态：0, 1, 2, 3。所以 $Q = \{0, 1, 2, 3\}$。
• 符号 (列): 表格的第一行列出了所有输入符号：ins, del。所以 $\Sigma = \{\text{ins}, \text{del}\}$。
• 起始状态: 状态 0 的行首有 "→"，所以 $q_0 = 0$。
• 接受状态: 状态 3 的行首有 "*"（原文写作 `${ }^{*} 3`，但含义是 `*3`），所以 $F = \{3\}$。
• 转移函数 (单元格内容):
• 在 "0" 行 "ins" 列，条目是 "1"，表示 $\delta(0, \text{ins}) = 1$。
• 在 "1" 行 "del" 列，条目是 "0"，表示 $\delta(1, \text{del}) = 0$。
• 在 "2" 行 "ins" 列，条目是 "3"，表示 $\delta(2, \text{ins}) = 3$。
• ... 以此类推，这个表格完整地定义了转移函数 δ。

这是一个非常经典和实用的DFA示例，用来模拟一个大小为 $k$ 的缓冲区 (Buffer) 的行为。缓冲区是计算机中用于临时存储数据的区域。

• 模型描述: 想象一个队列或一个容器，它最多能装 $k$ 个物品。我们可以执行两种操作：
• ins (insert): 向容器里放一个物品。
• del (delete): 从容器里拿走一个物品。
• 我们关心的是，经过一系列操作后，这个容器是否“满”了。

• DFA五元组解释:
• $Q=\{0,1,2, \ldots, k\}$:
• 状态被定义为从 0 到 $k$ 的整数。
• 每个状态 $i$ 的物理意义是：缓冲区中当前存放的物品数量。
• 状态 0 表示缓冲区是空的，状态 $k$ 表示缓冲区是满的。
• 这是一个有限集合，共有 $k+1$ 个状态。

• $\Sigma=\{\text { ins, del }\}$:
• 字母表包含两个符号，代表两种可以执行的操作。

• $\delta$:
• 这个转移函数定义了操作如何改变缓冲区的状态（物品数量）。它被分成了两个情况：
• $\delta(i, \text{ins}) = i+1 \text{ if } i < k \text{ else } = k$:
• 当你执行 ins 操作时：
• 如果缓冲区还没满 ($i < k$)，那么物品数量加一，状态从 $i$ 变为 $i+1$。
• 如果缓冲区已经满了 ($i=k$)，你再尝试放入物品，它也放不进去，所以物品数量保持不变，状态仍然是 $k$。else = k 部分处理了这种边界情况。
• $\delta(i, \text{del}) = i-1 \text{ if } i > 0 \text{ else } = 0$:
• 当你执行 del 操作时：
• 如果缓冲区不是空的 ($i > 0$)，那么物品数量减一，状态从 $i$ 变为 $i-1$。
• 如果缓冲区已经是空的 ($i=0$)，你再尝试取出物品，也取不出来，所以物品数量保持为0，状态仍然是 0。else = 0 部分处理了这种边界情况。

• $q_0 = 0$:
• 起始状态是 0，表示一开始缓冲区是空的。这很符合逻辑。

• $F = \{k\}$:
• 接受状态只有一个，就是状态 $k$。
• 这意味着，这个DFA所“接受”的，是那些能让缓冲区最终变满的操作序列。

这一部分详细描述了DFA的“运行”过程，即它如何一步步地处理一个输入字符串，并最终做出“接受”或“拒绝”的判断。同时，它引入了自动机语言的概念。

• 给定输入字符串...:
• $x=a_{1} a_{2} \ldots a_{n}$: 这是一个由 $n$ 个符号组成的输入字符串。$a_1$是第一个符号，$a_2$是第二个，以此类推。每个 $a_i$ 都必须是字母表 Σ 中的一员。
• DFA从状态 $q_0$ 开始: 计算的起点永远是起始状态。
• 读取 $a_1$ 并转移到状态 $\delta(q_0, a_1) = q_1$: 这是计算的第一步。机器查看第一个符号 $a_1$，应用转移函数 δ，从 $q_0$ 移动到新的状态 $q_1$。
• 然后读取 $a_2$ 并转移到状态 $\delta(q_1, a_2) = q_2$: 这是第二步。机器在新的状态 $q_1$ 上，查看第二个符号 $a_2$，再次应用转移函数，移动到 $q_2$。
• 依此类推: 这个过程一直持续，直到字符串中的所有符号都被读取完毕。
• DFA经过一系列状态 $q_0, q_1, q_2, \ldots, q_n$: 这是一个包含 $n+1$ 个状态的序列。$q_0$ 是起始状态，而 $q_i$ (对于 $i>0$) 是在读取了前 $i$ 个输入符号后达到的状态。注意，这些状态不一定是互不相同的，DFA可能会在某些状态之间来回访问。
• $\delta(q_{i-1}, a_i) = q_i$: 这是对上述过程的精确数学描述，定义了状态序列中相邻两项的关系。

• 输入被自动机接受或拒绝:
• 这是最终的判决时刻。在读取完最后一个符号 $a_n$ 并转移到最终状态 $q_n$ 后，计算结束。
• 接受 (accept): 如果这个最终状态 $q_n$ 属于接受状态集合 F (即 $q_n \in F$)，那么整个输入字符串 $x$ 就被DFA接受。
• 拒绝 (reject): 如果最终状态 $q_n$ 不属于接受状态集合 F (即 $q_n \notin F$)，字符串 $x$ 就被拒绝。
• 这是一个二元决策，对于任何给定的输入字符串，DFA的输出要么是“接受”，要么是“拒绝”，没有第三种可能。

• 自动机A的语言 L(A):
• 这是一个核心概念。一个自动机不仅仅是处理单个字符串，它定义了一个语言。
• 语言 (Language) 在形式语言理论中，指的是一个字符串的集合。
• L(A) 被定义为“所有能被自动机 A 接受的字符串”所构成的集合。
• 因此，一个DFA可以被看作是一个“成员资格测试器”。给定一个字符串 $x$ 和一个语言 $L(A)$，DFA A 的工作就是判断 $x$ 是否属于 $L(A)$。

这部分使用转移图的术语（节点、边、路径）重新解释了DFA的计算过程和语言定义，提供了一个更几何、更直观的视角。

• 对于每个节点...有一条唯一出边...:
• 这再次强调了DFA的确定性和完备性，并将其翻译成图论的语言。
• 在转移图中，从任何一个节点出发，对于字母表里的任意一个符号，都恰好有一个箭头指出去。不多也不少。这意味着路径是无歧义的。

• A在输入x上的计算(或运行):
• 这个概念被等同于在转移图中寻找一条特定的路径。
• 这条路径必须满足两个条件：

1. 从起始状态开始: 路径的起点必须是 $q_0$ 对应的节点。
2. 边上的标签序列是x: 如果 $x = a_1 a_2 \ldots a_n$，那么这条路径的第一条边的标签必须是 $a_1$，第二条边的标签必须是 $a_2$，以此类推。
   • 由于DFA的确定性，对于任何给定的输入字符串 $x$，这样的一条路径是唯一的。

• 路径上的节点序列 = DFA在输入x上的状态序列:
• 这建立了一个直接的对应关系。上一节讲的状态序列 $q_0, q_1, \ldots, q_n$ 正是这条唯一路径所依次经过的节点。

• 接受计算 (路径):
• 如果这条由输入 $x$ 决定的唯一路径，它的终点恰好是一个接受状态（双圆圈节点），那么这条路径就被称为“接受路径”。
• 一个输入字符串 $x$ 被接受，这件事情等价于它在图上对应的路径是一条接受路径。

• 自动机的语言L(A) = 所有接受路径的标签集合:
• 这是对语言 L(A) 的一个全新的、基于图的定义。
• 想象一下，在转移图中，所有可能的、从起始状态出发，到任意一个接受状态结束的路径。
• 把这些路径上所有的标签序列收集起来，组成一个集合，这个集合就是 L(A)。

• L(A) = {x | ...}:
• 这是对上述定义的更形式化的数学表达。
• 一个字符串 $x$ 在语言 L(A) 中，当且仅当（| 符号读作“当且仅当”或“满足条件”）在图中存在一条路径 $\pi$，这条路径 $\pi$ 从 $q_0$ 开始，在某个 $f \in F$ 结束，并且路径 $\pi$ 上的边的标签依次连接起来正好是字符串 $x$。

这部分通过一个具体的例子，演示了如何跟踪一个输入字符串在k=3缓冲区自动机上的执行路径，并对该自动机的语言给出了一个高层次的描述。

• 图片分析:
• 图片展示的是 $k=3$ 时的缓冲区自动机的转移图。
• $Q = \{0, 1, 2, 3\}$
• $q_0 = 0$ (起始箭头指向0)
• $F = \{3\}$ (节点3是双圆圈)
• $\Sigma = \{\text{ins}, \text{del}\}$
• 转移边与之前分析的一致，例如 $\delta(0, \text{ins})=1$, $\delta(3, \text{del})=2$, 等等。

• 输入字符串: ins ins ins del ins:
• 这是一个具体的输入样例。

• 路径: $0 \longrightarrow 1 \longrightarrow 2 \longrightarrow 3 \longrightarrow 2 \longrightarrow 3$:
• 这是对DFA处理该输入字符串时，所经过的状态序列的逐步展示。

1. 初始状态: $0$
2. 读 ins: 状态从 $0$ 变为 $1$。路径: $0 \rightarrow 1$。
3. 读 ins: 状态从 $1$ 变为 $2$。路径: $0 \rightarrow 1 \rightarrow 2$。
4. 读 ins: 状态从 $2$ 变为 $3$。路径: $0 \rightarrow 1 \rightarrow 2 \rightarrow 3$。
5. 读 del: 状态从 $3$ 变为 $2$。路径: $0 \rightarrow 1 \rightarrow 2 \rightarrow 3 \rightarrow 2$。
6. 读 ins: 状态从 $2$ 变为 $3$。路径: $0 \rightarrow 1 \rightarrow 2 \rightarrow 3 \rightarrow 2 \rightarrow 3$。
   • 计算结束: 整个字符串处理完毕，最终停在状态 3。
   • 判断: 因为最终状态 3 属于接受状态集 $F=\{3\}$，所以该字符串 "ins ins ins del ins" 被接受。

• 该自动机的语言:
• L(A) = 使缓冲区满的操作序列集合:
• 这句是对该DFA所识别的语言的自然语言描述。
• 它不是列举字符串，而是描述了这些字符串的共同属性。
• 一个操作序列（字符串）能被这个DFA接受，当且仅当在执行完这个序列后，缓冲区恰好是满的（即状态为 $k$）。
• 例如，"ins ins ins" (k=3) 会被接受。 "ins ins del ins ins" 也会被接受。但是 "ins ins" 不会被接受。

这一部分引入了一个非常重要的数学工具：扩展转移函数 (Extended Transition Function)，记作 $\delta^*$ (读作 delta-star)。它使我们能够一步到位地描述处理整个字符串后的状态，而不是像之前那样一步步地描述。

• 扩展 $\delta$ 到 $\delta^*$:
• 我们原始的转移函数 $\delta$ 只能处理单个符号，其定义域是 $Q \times \Sigma$。
• 我们现在想定义一个更强大的函数 $\delta^*$，它能直接处理整个字符串。它的定义域是 $Q \times \Sigma^*$。
• $\Sigma^*$: 这表示由字母表 $\Sigma$ 中符号组成的所有可能字符串的集合，包括空字符串 $\varepsilon$。这叫作字母表 $\Sigma$ 的克莱尼闭包 (Kleene Closure)。
• $\delta^*(q, x)$ 的含义: 其含义是“从状态 $q$ 开始，完整地读取整个字符串 $x$ 之后，会到达哪个状态？”。

• 归纳定义:
• 这种扩展通常使用归纳法 (Induction) 来定义，基于字符串的长度。
• Basis (基础情况): $x$ 的长度为0，即 $x=\varepsilon$ (空字符串)。
• $\delta^*(q, \varepsilon) = q$: 从任何状态 $q$ 开始，读取一个空字符串，什么也不做，所以状态保持不变，仍然是 $q$。这是归纳定义的基础。
• Induction (归纳步骤): 假设我们已经知道了如何处理长度为 $n$ 的字符串 $y$，现在要定义如何处理长度为 $n+1$ 的字符串 $x=ya$。
• $x = ya$: 任何一个非空字符串 $x$ 都可以看作是一个“前缀” $y$ 加上最后一个符号 $a$。
• $\delta^*(q, ya) = \delta(\delta^*(q, y), a)$: 这就是归纳的核心。这句话的含义是：

1. 要计算从 $q$ 开始读完 $ya$ 到达的状态...
2. ...我们首先计算从 $q$ 开始读完前缀 $y$ 到达的中间状态。根据 $\delta^*$ 的假设，这个状态是 $\delta^*(q, y)$。
3. 然后，我们从这个中间状态 $\delta^*(q, y)$ 出发，再读取最后一个符号 $a$。这可以通过原始的单步转移函数 $\delta$ 来完成。
4. 所以，最终状态就是 $\delta(\text{中间状态}, a)$，即 $\delta(\delta^*(q, y), a)$。

• 用 $\delta^*$ 重新定义语言 L(A):
• $\mathrm{L}(\mathrm{A})=\left\{\mathrm{x} \in \Sigma^{*} \mid \delta^{*}\left(\mathrm{q}_{0}, \mathrm{x}\right) \in \mathrm{F}\right\}$:
• 有了 $\delta^*$，语言的定义变得异常简洁。
• 一个字符串 $x$ 属于语言 L(A)，当且仅当，从起始状态 $q_0$ 开始，处理完整个字符串 $x$ 后到达的最终状态 $\delta^*(q_0, x)$ 是一个接受状态。
• 这与之前分步描述的定义是完全等价的，但数学上更优雅。
• 下面那行英文是对这个定义的重复解释。

这一部分给出了计算理论中一个最核心的定义之一：正则语言 (Regular Language)。

• 这个定义建立了一个至关重要的连接：它将一类语言（字符串的集合，是一个数学对象）与一类计算模型（有限自动机，是一个机器模型）等同起来。

• "如果存在一个有限自动机 A ...":
• 这句话是关键。要判断一个语言 L 是否是正则的，你需要做的就是去“寻找”一个DFA。
• 只要你能成功地构造出（或证明存在）哪怕一个DFA，它的语言 L(A) 正好就等于 L，那么 L 就是正则语言。
• 反之，如果对于一个语言 L，你能证明不可能存在任何DFA来识别它，那么 L 就不是正则语言。

• "...接受(或识别) L...":
• “接受 (accept)” 和 “识别 (recognize)” 在这里是同义词。它们都意味着自动机能够对任何字符串做出正确的“是/否”判断。
• 对于任何字符串 $x$：
• 如果 $x$ 属于 L，那么自动机 A 必须接受 $x$。
• 如果 $x$ 不属于 L，那么自动机 A 必须拒绝 $x$。

• "...即 L(A) = L...":
• 这是对“接受”或“识别”的数学化精确表述。两个集合相等，意味着它们包含完全相同的元素。
• $L(A) = L$ 意味着：

1. $L(A) \subseteq L$: 自动机 A 接受的每个字符串都确实在 L 中（自动机不会“误报”）。
2. $L \subseteq L(A)$: L 中的每个字符串都必须能被自动机 A 接受（自动机不会“漏报”）。

此部分通过一个具体的DFA示例，并同时给出其转移图和转移表两种表示，来巩固前面介绍的概念。

• 转移图分析:
• 状态: 三个节点，标记为 $q_0, q_1, q_2$。因此 $Q = \{q_0, q_1, q_2\}$。
• 字母表: 边上的标签只有 0 和 1。因此 $\Sigma = \{0, 1\}$。
• 起始状态: 有一个起始箭头指向 $q_0$。因此起始状态是 $q_0$。
• 接受状态: 节点 $q_2$ 是双圆圈。因此 $F = \{q_2\}$。
• 转移函数:
• 从 $q_0$ 出发：读 0 到 $q_1$，读 1 到 $q_0$。($\delta(q_0,0)=q_1, \delta(q_0,1)=q_0$)
• 从 $q_1$ 出发：读 0 到 $q_1$，读 1 到 $q_2$。($\delta(q_1,0)=q_1, \delta(q_1,1)=q_2$)
• 从 $q_2$ 出发：读 0 到 $q_2$，读 1 到 $q_2$。($\delta(q_2,0)=q_2, \delta(q_2,1)=q_2$)

• 转移表分析:
• 这个表格与上面的转移图是完全对应的。
• 行: 状态 $q_0, q_1, q_2$。
• 列: 符号 0, 1。
• 起始状态标记: $q_0$ 行首有 →。
• 接受状态标记: $q_0$ 和 $q_1$ 的行首有 *。等一下，这与转移图不符！
• 原文勘误/分析: 仔细观察原文的第二张图片（表格），星号 * 标记的是 $q_0$ 和 $q_1$。这与第一张图片（转移图）中只有 $q_2$ 是接受状态的表示是矛盾的。这是一个很好的例子，说明了讲义或笔记中可能出现的笔误。
• 我们先假设转移图是正确的，即 $F=\{q_2\}$。那么正确的转移表应该是：

• 再假设转移表是正确的，即 $F=\{q_0, q_1\}$。那么在转移图中，$q_0$ 和 $q_1$ 应该被画成双圆圈，而 $q_2$ 是单圆圈。
• 结论: 鉴于后续的示例，通常这类DFA是用来识别某种模式的，一旦模式匹配成功（进入$q_2$），就一直停留在接受状态。所以，转移图的表示（$F=\{q_2\}$）可能性更大，而表格中的星号可能是笔误。 我们将基于 $F=\{q_2\}$ 来分析这个DFA的语言。

• 语言分析 (假设 $F=\{q_2\}$):
• 这个DFA在寻找什么？
• 要到达接受状态 $q_2$，必须从状态 $q_1$ 读一个 1。
• 要到达状态 $q_1$，必须从状态 $q_0$ 读一个 0。
• 因此，任何被接受的字符串必须包含一个子串 01。
• 一旦读到 01，DFA就进入状态 $q_2$，这是一个“陷阱”状态或“吸收”状态，之后无论读到什么，都会留在 $q_2$。这意味着只要字符串中出现过一次 01，整个字符串就会被接受。
• 所以，该DFA的语言是：L = {所有包含子串 "01" 的二进制字符串}。

这一系列快速呈现的示例旨在通过模式识别，让学生快速掌握从DFA反推其语言的能力。我们来逐一分解。

第一个示例 (标题为“示例”，图包含q0, q1, q2)

• 这张图与上一节的图完全相同，可能是讲义排版重复或用于引出下一个例子。我们已经分析过，它识别的语言是 {所有包含子串 "01" 的二进制字符串}。

第二个示例 (图包含q0, q1, q2，但结构不同)

• 转移图分析:
• $Q = \{q_0, q_1, q_2\}$
• $\Sigma = \{0, 1\}$
• $q_0$ 是起始状态。
• $q_2$ 是接受状态。
• 转移:
• $q_0$: 读 0 到 $q_0$，读 1 到 $q_1$。
• $q_1$: 读 0 到 $q_0$，读 1 到 $q_2$。
• $q_2$: 读 0 或 1 都到 $q_2$ (陷阱状态)。
• 语言分析:
• 要到达 $q_2$，必须从 $q_1$ 读一个 1。
• 要到达 $q_1$，必须从 $q_0$ 读一个 1。
• 所以，路径中必须包含 $q_0 \xrightarrow{1} q_1 \xrightarrow{1} q_2$ 这一段。这对应于输入字符串中包含子串 11。
• 一旦读到 11，进入 $q_2$ 后就再也出不来了。
• 因此，该DFA识别的语言是 {所有包含子串 "11" 的二进制字符串}。
• 样本字符串验证:
• 11: $q_0 \xrightarrow{1} q_1 \xrightarrow{1} q_2$。终态 $q_2 \in F$。接受。
• 011: $q_0 \xrightarrow{0} q_0 \xrightarrow{1} q_1 \xrightarrow{1} q_2$。终态 $q_2 \in F$。接受。
• 101: $q_0 \xrightarrow{1} q_1 \xrightarrow{0} q_0 \xrightarrow{1} q_1$。终态 $q_1 \notin F$。拒绝。
• 01010: $q_0 \xrightarrow{0} q_0 \xrightarrow{1} q_1 \xrightarrow{0} q_0 \xrightarrow{1} q_1 \xrightarrow{0} q_0$。终态 $q_0 \notin F$。拒绝。
• 样本字符串与我们的分析完全吻合。

第三个示例 (与第二个图相同，但直接给出语言)

• 这个示例是对上一个分析的确认。它明确指出 语言 = 包含两个连续 1 的字符串集合。

第四个示例 (提问：该自动机的语言是什么？)

• 转移图分析:
• $Q = \{q_0, q_1, q_2\}$
• $\Sigma = \{0, 1\}$
• $q_0$ 是起始状态。
• $q_0$ 和 $q_1$ 是接受状态 (都是双圆圈)。
• 转移:
• $q_0$: 读 0 到 $q_0$, 读 1 到 $q_1$。
• $q_1$: 读 0 到 $q_0$, 读 1 到 $q_2$。
• $q_2$: 读 0 或 1 都到 $q_2$。
• 语言分析:
• 这个DFA的结构和上一个几乎一样，唯一的区别是接受状态集变了。现在 $F = \{q_0, q_1\}$。
• 这意味着，只要DFA停在 $q_0$ 或 $q_1$，字符串就被接受。
• 那么，什么时候会不被接受呢？只有当DFA停在 $q_2$ 时。
• 什么时候会进入 $q_2$ 呢？当且仅当字符串中出现了子串 11。一旦进入 $q_2$，就永远停在那里。
• 所以，这个DFA接受所有不会使它进入 $q_2$ 的字符串。
• 因此，该DFA识别的语言是 {所有不包含子串 "11" 的二进制字符串}。

第五个示例 (对第四个问题的回答)

• 这个示例确认了我们对上一个DFA的分析：语言 = 不包含两个连续 1 的字符串集合。

这一部分提出了一个关于正则语言的重要性质：闭包性质 (Closure Property)。具体来说，是关于补集 (Complement) 运算的闭包。

• 定理:
• “如果 L 是一个正则语言...那么它的补集 $\bar{L}$ 也是正则的。”
• 补集 $\bar{L}$ 的定义是 $\Sigma^* - L$。
• $\Sigma^*$ 是包含所有可能字符串的“全集”。
• $\bar{L}$ 就是那些在全集 $\Sigma^*$ 中，但不在 L 中的所有字符串的集合。
• 这个定理说明，正则语言这个大家族是“封闭”的。如果你在这个家族里随便挑一个语言 L，对它做“取补集”这个操作，得到的新语言 $\bar{L}$ 保证还在这个家族里，不会跑到外面去。

• 证明:
• 这是一个构造性证明 (Constructive Proof)。它不仅证明了结论成立，还给出了如何从识别 L 的DFA构造出识别 $\bar{L}$ 的DFA的具体方法。

1. 前提: L 是正则的。根据定义，这意味着存在一个DFA，我们称之为 $A$，它识别 L。即 $L(A) = L$。
2. 设 $A = (Q, \Sigma, \delta, q_0, F)$。
3. 构造: 我们现在构造一个新的DFA，称之为 $A'$。
   • $A' = (Q, \Sigma, \delta, q_0, F')$。
   • 注意，$A'$ 与 A 共享相同的状态集、字母表、转移函数和起始状态。
   • 唯一不同的是它的接受状态集，我们定义为 $F' = Q - F$。
   • $Q - F$ 表示所有在 $Q$ 中但不在 $F$ 中的状态。也就是说，我们把 A 中所有的接受状态都变成了非接受状态，同时把所有非接受状态都变成了接受状态。在转移图里，就是把所有双圆圈变成单圆圈，所有单圆圈变成双圆圈。
4. 论证: 我们需要证明这个新的自动机 $A'$ 确实识别 $\bar{L}$，即 $L(A') = \bar{L}$。
   • 考虑任意一个字符串 $x \in \Sigma^*$。
   • 当 A 处理 $x$ 时，它会到达一个最终状态 $p = \delta^*(q_0, x)$。
   • 当 $A'$ 处理同一个字符串 $x$ 时，由于它们的 $\delta$ 和 $q_0$ 完全相同，它也会到达完全相同的最终状态 $p = \delta^*(q_0, x)$。
   • 现在我们看 $x$ 是否被 $A'$ 接受：
   • $x$ 被 $A'$ 接受 $\iff p \in F' \iff p \in (Q - F) \iff p \notin F$。
   • 而 $p \notin F$ 意味着什么？意味着 $x$ 不被原始的自动机 A 接受，即 $x \notin L(A)$，即 $x \notin L$。
   • 因为 $x$ 是 $\Sigma^*$ 中任意的字符串，所以 $x \notin L \iff x \in \bar{L}$。
   • 综上，我们得到：$x$ 被 $A'$ 接受 $\iff x \in \bar{L}$。
   • 这完全符合“$A'$ 识别 $\bar{L}$”的定义。证明完毕。

• 图片和文字分析:
• 图片展示了一个通用的DFA，其状态被分成了两部分：接受状态 $F$ 和非接受状态 $Q-F$。
• 对于任何输入字符串，它最终要么落入 $F$ 区域，要么落入 $Q-F$ 区域。
• 在读取每个输入符号后...改变其状态: 这是对DFA基本工作方式的重申。
• 在每个时刻...决定了目前为止读取的输入是否在语言L中: 这句话在严格意义上是不准确的。DFA的当前状态只代表了到目前为止所读取输入的某种“摘要”或“分类”，它并不一定能决定当前读到的前缀是否在L中。只有在读取完整个字符串后，最终的状态才能决定整个字符串是否在L中。这是一个需要注意的细微差别。

这部分从理论转向实践，提供了一个设计有限自动机 (FA) 的通用方法论或思维框架。它将设计过程分解为三个核心步骤。

• 1. 确定输入符号/动作:
• 这是设计的第一步，也是最基础的一步。你需要明确你的自动机要处理的是什么样的数据。
• 这对应于定义五元组中的字母表 Σ。
• “动作”这个词暗示了自动机不仅可以用于语言识别，还可以为系统建模，其中输入符号代表了可以执行的动作（如 ins, del）。
• 例如，如果要处理二进制数，$\Sigma = \{0, 1\}$。如果要处理网页链接，$\Sigma$ 可能包含所有字母、数字和特殊符号。

• 2. 确定状态：在看到部分输入后，我们需要记住关于过去的什么，以便在未来做出正确决策？:
• 这是设计的核心和难点所在。
• 状态的本质是DFA的“记忆”。因为DFA只有有限个状态，所以它只能拥有有限的记忆。
• 在设计时，你必须问自己这个问题：当机器读到字符串的中间某处时，为了能对后续的输入做出正确的反应（即，走到正确的下一个状态，并最终做出正确的接受/拒绝判断），它必须记住哪些关于“已经读过的这部分前缀”的关键信息？
• 这个“关键信息”的种类不能是无限的。每一种不同的、需要被区分的关键信息，就对应着一个状态。
• 例如，在设计“包含'11'”的DFA时，我们需要记住的信息是：“我什么都没看到”， “我刚看到了一个'1'”，或者“我已经看到'11'了”。这三种不同的“记忆”就对应了三个状态。

• 3. 赋予状态意义：哪些输入字符串到达这个状态？:
• 这是对第二步的确认和深化。
• 一旦你根据“需要记住什么”初步设定了状态，最好给每个状态一个明确的、无歧义的“语义”或“意义”。
• 一个很好的方法就是用“到达这个状态的字符串所具有的共同属性”来描述这个状态的意义。
• 例如，在“包含'11'”的DFA中：
• $q_0$的意义：“所有到达此状态的字符串都不以'1'结尾”。
• $q_1$的意义：“所有到达此状态的字符串都以'1'结尾，但不包含'11'”。
• $q_2$的意义：“所有到达此状态的字符串都包含'11'”。
• 当你为每个状态赋予了清晰的意义后，设计转移函数就会变得非常容易。对于一个状态 $q$ 和输入 $a$，你只需考虑：一个具有 $q$ 所代表属性的字符串，在末尾添上一个 $a$ 之后，新的字符串会具有哪个状态的属性？这就是 $\delta(q, a)$ 的目标状态。

这个例子完整地应用了上一节提出的DFA设计方法论。

第一步：分析问题和确定输入

• 语言L: {所有恰好包含两个 '1' 的二进制字符串}。例如 "11", "0101", "1010" 都在 L 中，而 "1", "111", "00" 不在 L 中。
• 输入符号: 既然是二进制字符串，那么 $\Sigma=\{0,1\}$。

第二步：确定状态 (需要记住什么)

• 问题核心: 关键是'1'的数量。我们需要对'1'进行计数。
• 0的数量: 读到一个'0'会改变'1'的数量吗？不会。所以，到目前为止看到了多少个'0'是无关紧要的，我们不需要用状态去记忆它。
• 1的数量:
• 我们需要知道'1'的数量是不是2。
• 在读取过程中，'1'的数量可能是0个，1个，2个，3个，4个...
• 但是，一旦'1'的数量超过了2（例如变成3个），这个字符串就永远不可能“恰好”包含两个'1'了。它已经“失败”了。
• 所以，我们需要区分的关键信息是：

1. 到目前为止，有 0个 '1'。
2. 到目前为止，有 1个 '1'。
3. 到目前为止，有 恰好2个 '1'。
4. 到目前为止，有 多于2个 '1'。
   • 这四种不同的“记忆”就对应了我们需要的四个状态。

第三步：赋予状态意义并设计

• 状态命名和意义:
• $q_0$: 至今看到了 0个 '1'。
• $q_1$: 至今看到了 1个 '1'。
• $q_2$: 至今看到了 恰好2个 '1'。
• $q_3$: 至今看到了 多于2个 '1' (这是一个“失败”的陷阱状态)。
• DFA五元组:
• $Q = \{q_0, q_1, q_2, q_3\}$。
• $\Sigma = \{0, 1\}$。
• 起始状态: 空字符串 $\varepsilon$ 包含0个'1'，所以起始状态是 $q_0$。
• 接受状态: 我们的目标是“恰好包含两个'1'”。当整个字符串读完后，如果1的个数是2，就接受。所以，只有当最终停在 $q_2$ 状态时才接受。$F = \{q_2\}$。
• 转移函数 (参照转移图):
• 在状态 $q_0$ (0个'1'):
• 读 0: '1'的数量不变（还是0个）。所以留在 $q_0$。($\delta(q_0, 0)=q_0$)
• 读 1: '1'的数量从0个变成1个。进入 $q_1$。($\delta(q_0, 1)=q_1$)
• 在状态 $q_1$ (1个'1'):
• 读 0: '1'的数量不变（还是1个）。所以留在 $q_1$。($\delta(q_1, 0)=q_1$)
• 读 1: '1'的数量从1个变成2个。进入 $q_2$。($\delta(q_1, 1)=q_2$)
• 在状态 $q_2$ (2个'1'):
• 读 0: '1'的数量不变（还是2个）。所以留在 $q_2$。($\delta(q_2, 0)=q_2$)
• 读 1: '1'的数量从2个变成3个（多于2个）。进入“失败”状态 $q_3$。($\delta(q_2, 1)=q_3$)
• 在状态 $q_3$ (>2个'1'):
• 读 0 或 1: '1'的数量只可能保持或增加，但肯定还是多于2个。所以永远留在“失败”状态 $q_3$。($\delta(q_3, 0)=q_3, \delta(q_3, 1)=q_3$)
• 讲义中的转移图完美地呈现了以上所有转移规则。

这个例子是另一个经典的计数问题，但比上一个更精妙，因为它涉及到“模运算”的思想。

第一步：分析问题和确定输入

• 语言L: {所有包含偶数个 '1' 的二进制字符串}。偶数包括0。
• 输入符号: $\Sigma=\{0,1\}$。

第二步：确定状态 (需要记住什么)

• 问题核心: 关键是'1'的数量是偶数还是奇数，也就是奇偶性 (Parity)。
• 0的数量: 读到一个'0'不改变'1'的数量，因此也不改变'1'的奇偶性。所以'0'的数量是无关紧要的。
• 1的数量:
• 如果当前'1'的个数是偶数，再读一个'1'，个数就变成奇数。
• 如果当前'1'的个数是奇数，再读一个'1'，个数就变成偶数。
• 我们不需要记住具体的'1'的个数（是2个，还是4个，还是100个），我们只需要记住这个数除以2的余数是0（偶数）还是1（奇数）。
• 因此，我们只需要两种“记忆”：

1. 到目前为止，'1'的个数是偶数。
2. 到目前为止，'1'的个数是奇数。
   • 这两种记忆对应两个状态。

第三步：赋予状态意义并设计

• 状态命名和意义:
• even: 至今看到了偶数个'1'。
• odd: 至今看到了奇数个'1'。
• DFA五元组:
• $Q = \{\text{even}, \text{odd}\}$。
• $\Sigma = \{0, 1\}$。
• 起始状态: 空字符串 $\varepsilon$ 包含0个'1'，0是偶数。所以起始状态是 even。$q_0 = \text{even}$。
• 接受状态: 我们的目标是“包含偶数个'1'”。所以，如果最终停在 even 状态，就接受。$F = \{\text{even}\}$。
• 转移函数 (参照转移图和转移表):
• 在状态 even (偶数个'1'):
• 读 0: '1'的数量不变，奇偶性不变（还是偶数）。留在 even。
• 读 1: '1'的数量加一，奇偶性从偶数变为奇数。进入 odd。
• 在状态 odd (奇数个'1'):
• 读 0: '1'的数量不变，奇偶性不变（还是奇数）。留在 odd。
• 读 1: '1'的数量加一，奇偶性从奇数变为偶数。进入 even。
• 讲义中的转移图和转移表都清晰地反映了这些规则。在这个例子中，图和表是完全一致的。

这部分介绍了如何严格地、数学化地证明我们设计的DFA是正确的，即它识别的语言确实是我们想要的那个语言。仅仅通过测试几个例子是不够的，我们需要一个能覆盖所有无穷多个字符串的逻辑论证。

• 证明 L(A) = L 的两个方向:
• 在数学中，证明两个集合相等（这里 L(A) 和 L 都是字符串的集合）的标准方法是证明它们互为子集。
• 1. 证明 $L(A) \subseteq L$ (完备性/Soundness):
• 这需要证明：如果一个字符串 $x$ 被自动机 A 接受，那么它一定是我们目标语言 L 的成员。
• 这保证了我们的DFA不会接受任何它不应该接受的字符串（没有“误报”）。
• 2. 证明 $L \subseteq L(A)$ (正确性/Completeness):
• 这需要证明：如果一个字符串 $x$ 是我们目标语言 L 的成员，那么它一定会被自动机 A 接受。
• 这保证了我们的DFA会接受所有它应该接受的字符串（没有“漏报”）。

• 通常可以同时做两个方向 (当且仅当):
• 如果我们的证明逻辑是“当且仅当” (if and only if, iff, $\Leftrightarrow$) 的形式，那么就可以一次性完成两个方向的证明。例如，证明“$x$ 被 A 接受 $\Leftrightarrow x \in L$”。

• 证明方法：对x的长度进行归纳:
• 由于语言通常包含无限多个字符串，我们无法逐一检验。数学归纳法 (Mathematical Induction) 是处理这种无限情况的强大工具。
• 证明将基于输入字符串 $x$ 的长度 $|x|$ 来进行。
• 基础步骤 (Base Case): 证明结论对于长度为0的字符串（即空字符串 $\varepsilon$）成立。
• 归纳步骤 (Inductive Step): 假设结论对于所有长度为 $k$ 的字符串都成立（这被称为归纳假设），然后利用这个假设来证明结论对于所有长度为 $k+1$ 的字符串也成立。

• 加强断言 (归纳假设):
• 这是进行此类证明的关键技巧。
• 如果我们只假设“对于长度为k的字符串x，x被接受 $\Leftrightarrow x \in L$”，这个假设可能不够强大，无法帮助我们推导出长度为 $k+1$ 的情况。
• 一个更强的断言是，我们不仅要知道哪些字符串被接受，我们还要知道所有字符串（无论是否属于L）会把DFA带到哪个状态。
• 我们要证明的断言的形式通常是：“对于任意字符串 $x$，$\delta^*(q_0, x)$ 到达的状态，正好对应于 $x$ 所具有的某种属性”。这个属性必须与我们设计状态时的“意义”相吻合。
• 通过证明这个更强、更全面的断言，关于“接受”的结论（即最终状态是否在F中）就会自然而然地成为这个强断言的一个特例或推论。

这部分完整地演示了如何使用上一节介绍的方法，来证明“奇偶校验”DFA的正确性。

1. 设定加强的归纳断言 (Inductive Hypothesis Statement)

• 我们要证明的目标不仅仅是“当x有偶数个1时被接受”，而是更强的断言，它描述了任何字符串x最终会到达哪个状态。
• 断言 P(x): 字符串 $x$ 会将DFA从起始状态 $q_0$ (即 even) 驱动到...
• ...状态 even，当且仅当 $x$ 包含偶数个 '1'。
• ...状态 odd，当且仅当 $x$ 包含奇数个 '1'。
• 这个断言将DFA的最终状态与字符串的内在数学属性（'1'的个数的奇偶性）完全绑定。

2. 形式化证明 (Proof by Induction on |x|)

• 基础步骤 (Base Case): 证明 P(x) 对长度为 0 的字符串 $x=\varepsilon$ 成立。
• DFA方面: 根据扩展转移函数的定义，$\delta^*(q_0, \varepsilon) = q_0$。在这个DFA中，$q_0 = \text{even}$。
• 语言方面: 空字符串 $\varepsilon$ 中包含 0 个 '1'。数字 0 是一个偶数。
• 比较: $\delta^*(q_0, \varepsilon)$ 到达了 even 状态，而 $\varepsilon$ 确实包含偶数个'1'。断言成立。

• 归纳步骤 (Inductive Step):
• 归纳假设 (Inductive Hypothesis): 假设断言 P(y) 对于所有长度为 $k$ 的字符串 $y$ 都成立。即，我们假设已经知道 $\delta^*(q_0, y)$ 的结果精确地反映了 $y$ 中'1'的奇偶性。
• 要证明的目标: 证明断言 P(x) 对于任何长度为 $k+1$ 的字符串 $x$ 也成立。
• 任何长度为 $k+1$ 的字符串 $x$ 都可以写成 $x = ya$ 的形式，其中 $y$ 是一个长度为 $k$ 的字符串，而 $a$ 是最后一个符号（$a \in \{0, 1\}$）。
• 案例分析 (Case Analysis): 我们根据最后一个符号 $a$ 的值分两种情况讨论。

• Case 1: $a=0$
• 语言方面: 如果 $x = y0$，那么 $x$ 中'1'的数量与 $y$ 中'1'的数量完全相同。所以，$x$ 的奇偶性与 $y$ 的奇偶性相同。
• DFA方面: 我们来计算 $\delta^*(q_0, x) = \delta^*(q_0, y0)$。
• 根据扩展转移函数的定义: $\delta^*(q_0, y0) = \delta(\delta^*(q_0, y), 0)$。
• 根据我们的归纳假设，我们知道 $\delta^*(q_0, y)$ 是哪个状态（even或odd）。
• 如果 $y$ 有偶数个'1'，那么 $\delta^*(q_0, y) = \text{even}$。此时，$\delta(\text{even}, 0) = \text{even}$。
• 如果 $y$ 有奇数个'1'，那么 $\delta^*(q_0, y) = \text{odd}$。此时，$\delta(\text{odd}, 0) = \text{odd}$。
• 在这两种子情况下，最终状态都与 $\delta^*(q_0, y)$ 的状态相同。
• 比较: $x$ 的奇偶性与 $y$ 相同，而DFA处理 $x$ 之后的状态也与处理 $y$ 之后的状态相同。由于我们假设了处理 $y$ 之后状态的正确性，所以处理 $x$ 之后状态的正确性也得到了保证。断言在 $a=0$ 的情况下成立。

• Case 2: $a=1$
• 语言方面: 如果 $x = y1$，那么 $x$ 中'1'的数量比 $y$ 中'1'的数量多一个。所以，$x$ 的奇偶性与 $y$ 的奇偶性相反。
• DFA方面: 我们来计算 $\delta^*(q_0, x) = \delta^*(q_0, y1)$。
• 定义: $\delta^*(q_0, y1) = \delta(\delta^*(q_0, y), 1)$。
• 根据归纳假设:
• 如果 $y$ 有偶数个'1'，那么 $\delta^*(q_0, y) = \text{even}$。此时，$\delta(\text{even}, 1) = \text{odd}$。
• 如果 $y$ 有奇数个'1'，那么 $\delta^*(q_0, y) = \text{odd}$。此时，$\delta(\text{odd}, 1) = \text{even}$。
• 在这两种子情况下，最终状态都与 $\delta^*(q_0, y)$ 的状态相反。
• 比较: $x$ 的奇偶性与 $y$ 相反，而DFA处理 $x$ 之后的状态也与处理 $y$ 之后的状态相反。因此，断言在 $a=1$ 的情况下也成立。

• 结论: 由于基础步骤成立，并且归纳步骤对所有可能的情况都成立，因此根据数学归纳法原理，我们证明了加强的断言 P(x) 对所有字符串 $x \in \Sigma^*$ 都成立。

• 最终推论:
• 既然 P(x) 成立，那么一个字符串 $x$ 被此DFA接受 $\iff \delta^*(q_0, x) \in F \iff \delta^*(q_0, x) = \text{even}$。
• 根据我们已证的 P(x)，$\delta^*(q_0, x) = \text{even} \iff x$ 包含偶数个'1'。
• 因此，$x$ 被接受 $\iff x$ 包含偶数个'1'。这正是 $L(A) = L$ 的定义。证明完成。

这部分将“奇偶校验”（即模2计数）的思想推广到更一般的情况——模k计数。

第一个示例：1的数量是3的倍数

• 问题: 设计一个DFA，接受所有'1'的个数是3的倍数（0, 3, 6, ...）的二进制字符串。
• 设计思路 (应用模k思想):
• 我们需要记住'1'的个数除以3的余数。
• 余数可能是 0, 1, 或 2。这三种需要区分的“记忆”对应三个状态。
• 状态意义:
• $q_0$: '1'的个数模3余0。
• $q_1$: '1'的个数模3余1。
• $q_2$: '1'的个数模3余2。
• DFA设计与转移图分析:
• $Q = \{q_0, q_1, q_2\}$
• $\Sigma = \{0, 1\}$
• 起始状态: 空字符串有0个'1'，0模3余0。所以 $q_0$ 是起始状态。
• 接受状态: 目标是'1'的个数是3的倍数，即模3余0。所以 $F = \{q_0\}$。
• 转移:
• 读'0'不改变'1'的个数，因此也不改变余数。所以，对于任何状态 $q_i$，$\delta(q_i, 0) = q_i$。在图上表现为每个状态都有一个指向自己的标'0'的环。
• 读'1'使'1'的个数加1，余数也加1（模3）。
• 在 $q_0$ (余0) 读'1'，余数变1。进入 $q_1$。
• 在 $q_1$ (余1) 读'1'，余数变2。进入 $q_2$。
• 在 $q_2$ (余2) 读'1'，余数变3，3模3余0。回到 $q_0$。
• 讲义中的转移图完美地展示了这个循环结构。

第二个示例：推广到 k 的倍数

• 这部分将上述思想形式化和推广。
• 问题: 为任意给定的整数 $k>1$，设计一个DFA，接受所有'1'的个数是 $k$ 的倍数的二进制字符串。
• DFA的通用构造:
• $Q = \{q_0, q_1, \ldots, q_{k-1}\}$: 我们需要 $k$ 个状态，分别代表'1'的个数模 $k$ 的余数：0, 1, ..., k-1。状态 $q_i$ 的意义是“到目前为止'1'的个数等于 $i \pmod k$”。
• $\Sigma = \{0, 1\}$: 字母表不变。
• $\delta(q_i, 0) = q_i$: 读'0'不改变余数，状态不变。
• $\delta(q_i, 1) = q_{i+1 \pmod k}$: 读'1'使余数加1。这里的 i+1 mod k 是关键。
• 如果 $i < k-1$，那么 $i+1 \pmod k = i+1$。所以状态从 $q_i$ 迁移到 $q_{i+1}$。
• 如果 $i = k-1$，那么 $i+1 = k$，$k \pmod k = 0$。所以状态从 $q_{k-1}$ 迁移回 $q_0$。这构成了一个长度为 $k$ 的循环。
• 起始状态 $= q_0$: 0个'1'模k余0。
• 接受状态 $= \{q_0\}$: k的倍数模k余0。

这部分提供了一系列练习题，旨在让学生运用前面学到的设计原则（尤其是模k计数）来解决类似但略有不同的问题。

练习题1: 接受所有长度可被 5 整除的字符串

• 分析:
• 这个问题是模k计数的直接应用。
• 我们不关心字符串里有什么符号，只关心它的长度。
• 每读一个符号，长度就加1。
• 我们需要计算字符串长度模5的余数。
• 设计:
• 状态: 5个状态，$q_0, q_1, q_2, q_3, q_4$，分别代表长度模5余0, 1, 2, 3, 4。
• 字母表: 题目未指定，可以假设是 $\Sigma=\{a, b\}$ 或任何非空字母表。
• 起始状态: $q_0$ (空字符串长度为0，0模5余0)。
• 接受状态: $F = \{q_0\}$ (长度是5的倍数，模5余0)。
• 转移: 对于任何输入符号 $c \in \Sigma$，它都使长度加1，即余数加1。所以 $\delta(q_i, c) = q_{i+1 \pmod 5}$。这是一个包含5个状态的简单环，所有符号都驱动同一个方向的转移。

练习题2: 接受表示可被 5 整除的十进制数的字符串

• 分析:
• 这个问题不再是简单地计长度或符号个数。它关系到字符串所表示的数值。
• 一个十进制数能被5整除的充要条件是：它的最后一位是 '0' 或 '5'。
• DFA需要记住什么？它只需要记住上一个读到的符号是什么，就能判断整个数能否被5整除。但我们需要考虑整个字符串。当字符串读完时，最后一个符号是什么？
• 设计:
• 状态: 我们可以设计两个状态。
• $q_0$: 结尾数字是 '0' 或 '5'。
• $q_1$: 结尾数字不是 '0' 或 '5'。
• 字母表: $\Sigma = \{'0', '1', ..., '9'\}$。
• 起始状态: 这个问题有个歧义。如果把空字符串看作数字0，那么0能被5整除，起始状态应该是接受状态。但通常我们不把空字符串看作数字。我们假设一个更简单的模型：DFA只需要在读完非空字符串后做出判断。
• 让我们重新设计状态：
• $q_{start}$: 初始状态。
• $q_{accept}$: 最后一个读到的数字是 '0' 或 '5'。
• $q_{reject}$: 最后一个读到的数字不是 '0' 或 '5'。
• 转移:
• 从 $q_{start}$ 开始，读到 '0' 或 '5'，进入 $q_{accept}$。读到其他数字，进入 $q_{reject}$。
• 在 $q_{accept}$ 时，下一个读到 '0' 或 '5'，留在 $q_{accept}$。读到其他，进入 $q_{reject}$。
• 在 $q_{reject}$ 时，下一个读到 '0' 或 '5'，进入 $q_{accept}$。读到其他，留在 $q_{reject}$。
• 起始状态: $q_{start}$。
• 接受状态: $F = \{q_{accept}\}$。此外，数字 "0" 本身也应被接受。单独的 "0" 会使DFA进入 $q_{accept}$。空字符串 $\varepsilon$ 呢？如果它代表0，那么 $q_{start}$ 也应该是接受状态。我们采纳题目例子0被接受，那么$q_{start}$读到0后进入的状态$q_{accept}$必须是接受状态。
• 这个模型对于"0", "5", "025", "155" 都有效。

练习题3: 接受表示可被 3 整除的十进制数的字符串

• 分析:
• 一个数能被3整除的充要条件是：它的各位数字之和能被3整除。
• 这又回到了模运算！我们需要计算各位数字之和模3的余数。
• 当从左到右读一个数字字符串时，数值是如何变化的？如果当前读到的前缀代表的数是 $N$，下一个数字是 $d$，那么新的数是 $N' = 10 \times N + d$。
• 我们关心的是数值模3的余数。$N' \pmod 3 = (10 \times N + d) \pmod 3 = (1 \times N + d) \pmod 3 = (N \pmod 3 + d \pmod 3) \pmod 3$。
• 这个发现是关键！新余数只依赖于旧余数和新数字。这正是DFA能解决的问题！
• 设计:
• 状态: 三个状态，$q_0, q_1, q_2$，分别代表当前数值模3余0, 1, 2。
• 字母表: $\Sigma = \{'0', ..., '9'\}$。
• 起始状态: $q_0$ (空字符串代表0，0模3余0)。
• 接受状态: $F = \{q_0\}$。
• 转移: $\delta(q_i, d) = q_{(i+d) \pmod 3}$。例如:
• 在 $q_1$ (余1)，读 '5' (值5)。新余数是 $(1+5)\pmod 3 = 6 \pmod 3 = 0$。所以 $\delta(q_1, '5') = q_0$。
• 在 $q_2$ (余2)，读 '8' (值8)。新余数是 $(2+8)\pmod 3 = 10 \pmod 3 = 1$。所以 $\delta(q_2, '8') = q_1$。

练习题4: 接受表示可被 3 整除的二进制数的字符串

• 分析:
• 这和上题类似，但基数是2。
• 如果当前前缀代表的数是 $N$，下一个数字是 $d \in \{0, 1\}$，那么新的数是 $N' = 2 \times N + d$。
• 我们关心数值模3的余数。$N' \pmod 3 = (2 \times N + d) \pmod 3 = (-1 \times (N \pmod 3) + d) \pmod 3$。
• 新余数仍然只依赖于旧余数和新数字！
• 设计:
• 状态: 三个状态，$q_0, q_1, q_2$，代表当前数值模3余0, 1, 2。
• 字母表: $\Sigma = \{0, 1\}$。
• 起始状态: $q_0$ (空字符串$\varepsilon$或"0"都代表0，0模3余0)。
• 接受状态: $F = \{q_0\}$。
• 转移:
• 从 $q_i$ 读 '0' ($d=0$): 新余数是 $(2i) \pmod 3$。
• $\delta(q_0, 0) = q_0$ ((2*0)%3=0)
• $\delta(q_1, 0) = q_2$ ((2*1)%3=2)
• $\delta(q_2, 0) = q_1$ ((2*2)%3=1)
• 从 $q_i$ 读 '1' ($d=1$): 新余数是 $(2i+1) \pmod 3$。
• $\delta(q_0, 1) = q_1$ ((2*0+1)%3=1)
• $\delta(q_1, 1) = q_0$ ((2*1+1)%3=0)
• $\delta(q_2, 1) = q_2$ ((2*2+1)%3=2)
• 验证: 字符串 "110" 代表6。
• $q_0 \xrightarrow{1} q_1 \xrightarrow{1} q_0 \xrightarrow{0} q_0$。最终在 $q_0$，接受。正确。
• 字符串 "11" 代表3。
• $q_0 \xrightarrow{1} q_1 \xrightarrow{1} q_0$。最终在 $q_0$，接受。正确。

这部分内容展示了如何组合两个简单的DFA来解决一个更复杂的问题，引出了乘积构造 (Product Construction) 的思想。

• 回顾两个基本DFA:

1. 偶数个'1'的DFA: 有两个状态，{even_1, odd_1}。读'1'时状态翻转，读'0'时状态不变。
2. 偶数个'0'的DFA: 同样有两个状态，{even_0, odd_0}。读'0'时状态翻转，读'1'时状态不变。

• 新问题: 接受同时满足“偶数个'0'”和“偶数个'1'”的字符串。
• 分析 (需要记住什么): 在读取字符串的过程中，为了对未来的输入做正确判断，我们同时需要记住两件事：

1. 到目前为止，'0'的个数的奇偶性。
2. 到目前为止，'1'的个数的奇偶性。
   • 状态设计: 每一份“组合记忆”就对应一个新状态。
   • '0'是偶数，'1'是偶数 $\rightarrow$ 状态 ee (even-even)
   • '0'是偶数，'1'是奇数 $\rightarrow$ 状态 eo (even-odd)
   • '0'是奇数，'1'是偶数 $\rightarrow$ 状态 oe (odd-even)
   • '0'是奇数，'1'是奇数 $\rightarrow$ 状态 oo (odd-odd)
   • 这四个状态正好是两个基本DFA状态集的笛卡尔积: $\{even_0, odd_0\} \times \{even_1, odd_1\}$。

• DFA设计:
• Q = {ee, eo, oe, oo}: 4个状态。
• Σ = {0, 1}
• 起始状态 $q_0$: 空字符串有0个'0'和0个'1'，都是偶数。所以起始状态是 ee。
• 接受状态 F: 目标是“偶数个0”和“偶数个1”。所以只有 ee 状态满足条件。$F = \{\text{ee}\}$。
• 转移函数 (分析转移图):
• 在状态 ee (偶0, 偶1):
• 读 0: '0'的奇偶性变奇，'1'不变。进入 oe (奇0, 偶1)。
• 读 1: '0'的奇偶性不变，'1'变奇。进入 eo (偶0, 奇1)。
• 在状态 eo (偶0, 奇1):
• 读 0: '0'的奇偶性变奇，'1'不变。进入 oo (奇0, 奇1)。
• 读 1: '0'的奇偶性不变，'1'变偶。进入 ee (偶0, 偶1)。
• ... 以此类推。可以发现，新DFA的转移，就像两个基本DFA在并行独立地进行自己的状态转移。
• 例如，从ee读0：
• “偶数0”的DFA从 even_0 读0，进入 odd_0。
• “偶数1”的DFA从 even_1 读0，停在 even_1。
• 两者组合起来，就是从 (even_0, even_1) 进入了 (odd_0, even_1)，即从 ee 进入 oe。

这一部分正式提出了乘积构造法，并用它来证明正则语言对于并集和交集运算是封闭的。

• 定理:
• 这个定理声明了正则语言家族的另外两个重要的闭包性质。
• 交集 (Intersection) $L_1 \cap L_2$: 一个字符串 $x$ 属于交集，当且仅当 $x$ 既属于 $L_1$ 又属于 $L_2$。
• 并集 (Union) $L_1 \cup L_2$: 一个字符串 $x$ 属于并集，当且仅当 $x$ 或者属于 $L_1$ 或者属于 $L_2$（或两者都属于）。
• 定理说，如果 $L_1$ 和 $L_2$ 都能被DFA识别，那么它们的交集和并集也一定能被某个（可能是更复杂的）DFA识别。

• 乘积构造 (Product Construction):
• 这是用来证明上述定理的构造性方法。其核心思想与上一节的例子完全相同：并行模拟两个DFA。
• 给定两个自动机:
• $A_1 = (Q_1, \Sigma, \delta_1, q_{1,0}, F_1)$ 识别 $L_1$。
• $A_2 = (Q_2, \Sigma, \delta_2, q_{2,0}, F_2)$ 识别 $L_2$。(注意，两个DFA的字母表 $\Sigma$ 必须相同)。
• 构造乘积自动机 M:
• 状态集 $Q$: 新的状态集是 $A_1$ 和 $A_2$ 状态集的笛卡尔积 $Q_1 \times Q_2$。新机器的每个状态都是一个形如 $(p_1, p_2)$ 的有序对，其中 $p_1 \in Q_1, p_2 \in Q_2$。这个状态的意义是：“$A_1$ 现在处于状态 $p_1$，同时 $A_2$ 现在处于状态 $p_2$”。
• 字母表 $\Sigma$: 与原来相同。
• 起始状态 $q_0$: 新的起始状态是两个原始起始状态组成的有序对 $(q_{1,0}, q_{2,0})$。
• 转移函数 $\delta$:
• $\delta((p_1, p_2), a) = (\delta_1(p_1, a), \delta_2(p_2, a))$
• 这一定义是核心。它表明，新机器从组合状态 $(p_1, p_2)$ 读入一个符号 $a$ 后的下一个状态，是由 $A_1$ 和 $A_2$ 各自独立计算其下一个状态，然后将结果组合而成。$A_1$ 从 $p_1$ 变为 $\delta_1(p_1, a)$，$A_2$ 从 $p_2$ 变为 $\delta_2(p_2, a)$。
• 接受状态集 F: 这是区分并集和交集的关键所在。新机器 M 的骨架（状态和转移）是相同的，但“胜利条件”不同。
• 对于交集 ($L_1 \cap L_2$):
• 一个字符串 $x$ 要被接受，必须同时被 $A_1$ 和 $A_2$ 接受。
• 这意味着在处理完 $x$ 后，M 的最终状态 $(p_1, p_2)$ 必须满足 $p_1$ 是 $A_1$ 的接受状态 且 $p_2$ 是 $A_2$ 的接受状态。
• 所以, $F_{intersect} = \{(p_1, p_2) \mid p_1 \in F_1 \text{ and } p_2 \in F_2\}$。这等价于 $F_1 \times F_2$。
• 对于并集 ($L_1 \cup L_2$):
• 一个字符串 $x$ 要被接受，只要被 $A_1$ 或 $A_2$ 之一接受即可。
• 这意味着在处理完 $x$ 后，M 的最终状态 $(p_1, p_2)$ 必须满足 $p_1$ 是 $A_1$ 的接受状态 或 $p_2$ 是 $A_2$ 的接受状态。
• 所以, $F_{union} = \{(p_1, p_2) \mid p_1 \in F_1 \text{ or } p_2 \in F_2\}$。

这一部分提出了一个普遍的结论：任何只包含有限多个字符串的语言，都是正则语言。并给出了一个构造相应DFA的通用方法。

• 定理: 如果一个语言 L 是一个有限的字符串集合，那么 L 是正则的。

• 证明思路:
• 我们可以通过为这个有限集合 L 构造一个识别它的DFA来证明这一点。
• 这个构造方法分为两步：

1. 为 L 中的所有字符串构建一个“Trie”（也称前缀树）。
2. 对这个 Trie 进行一些修改，使其成为一个完整的DFA。

• 示例分析 L = {00, 01, 011, 101}:
• Trie数据结构:
• Trie 是一种树状数据结构，用于高效地存储和检索字符串集合。
• 从根节点开始，每个节点的边代表一个字符，从根到一个节点的路径就构成了一个字符串前缀。
• 我们将 L 中的所有字符串 "00", "01", "011", "101" 都插入到 Trie 中。
• 根节点: 代表空字符串 $\varepsilon$。
• 插入 "00": 根 $\xrightarrow{0}$ 节点A $\xrightarrow{0}$ 节点B。
• 插入 "01": 根 $\xrightarrow{0}$ 节点A (已存在) $\xrightarrow{1}$ 节点C。
• 插入 "011": 根 $\xrightarrow{0}$ 节点A $\xrightarrow{1}$ 节点C (已存在) $\xrightarrow{1}$ 节点D。
• 插入 "101": 根 $\xrightarrow{1}$ 节点E $\xrightarrow{0}$ 节点F $\xrightarrow{1}$ 节点G。
• Trie 建好后，树中的某些节点对应于 L 中的完整字符串。我们需要标记它们。在图中，这些节点（B, C, D, G）被画成了双圆圈，表示它们是接受状态。

• 从 Trie 到 DFA:
• 上面的 Trie 结构还不是一个完整的DFA，因为它不满足完备性。例如，从根节点出发，只有标 '0' 和 '1' 的出边，没有标其他可能符号的边（如果字母表更大的话）。更重要的是，比如从节点B（对应"00"）出发，没有定义读 '0' 或 '1' 该去哪里。
• 为了将其变为DFA，我们需要：

1. 将节点视为状态: Trie 的每个节点都成为DFA的一个状态。根节点是起始状态。
2. 标记接受状态: 所有代表 L 中完整字符串的节点，都成为接受状态。
3. 添加“死状态”: 我们引入一个额外的、非接受的“死状态”（dead state）或“陷阱状态”。在图中，这个状态没有被画出来，但我们可以想象它的存在。
4. 补全转移: 对于图中任何一个节点，如果它缺少某个符号的出边，我们就画一条指向“死状态”的边。例如，从根节点出发，如果输入不是'0'或'1'，就去死状态。从节点B（"00"）出发，再读任何符号（'0'或'1'）都会进入死状态，因为它不再是 L 中任何字符串的前缀了。一旦进入死状态，之后读任何符号都停留在死状态。
   • 最终结论: 通过“Trie + 死状态”的方法，我们总能为任何一个有限语言 L 构建一个识别它的DFA。因此，所有有限语言都是正则的。