22、自动机模型：从双栈自动机到线程自动机

吃瓜不吐籽595

于 2025-11-18 14:26:07 发布

阅读量10

点赞数

CC 4.0 BY-SA版权

分类专栏：超越上下文无关文法文章标签：双栈自动机强驱动双栈自动机线程自动机

本文链接：https://blog.youkuaiyun.com/oauth7security/article/details/155044634

超越上下文无关文法专栏收录该内容

24 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

自动机模型：从双栈自动机到线程自动机

在计算理论和自然语言处理中，自动机是一种强大的工具，用于处理和识别各种语言结构。本文将介绍几种自动机模型，包括双栈自动机（2 - SA）、强驱动双栈自动机（SD - 2SA）和线程自动机（TA），并详细探讨它们的工作原理、定义和应用。

1. 双栈自动机（2 - SA）

双栈自动机是一种具有两个栈的自动机模型，可用于处理树邻接语法（TAG）等复杂的语言结构。以下是一个具体的双栈自动机示例：
- 自动机定义 ：$M = ⟨{q}, {a, b, c}, Γ, δ, q, ∅, #⟩$，其中$Γ = {#, Rα, Rβ, F, A, B, C}$。
- 转移函数 ：转移函数$δ$定义了自动机在不同状态和栈内容下的转移规则，例如：
- $\langle q, R⊤_α, ε⟩∈δ(q, ε, #, #)$：开始初始树的遍历。
- $\langle q, R⊥_α, X⟩∈δ(q, ε, R⊤_α, X)$：预测在$Rα$处无附加操作。
- $\langle q, C, X⟩∈δ(q, ε, R⊥_α, X)$：向下移动。

以下是该双栈自动机的一个示例运行过程：
| 栈 1 | 栈 2 | 剩余输入 | 操作说明 |
| — | — | — | — |
| ‡# | ‡# | aacbb | 初始状态 |
| ‡$R⊤_α$ | ‡ | aacbb | 开始遍历$α$ |
| ‡$R⊥_α R⊤_β$ | ‡ | aacbb | 预测$β$的附加操作 |
| ‡$R⊥_α R⊥_β R⊤_β$ | ‡ | aacbb | 预测$β$的附加操作 |
| ‡$R⊥_α R⊥_β R⊥_β$ | ‡ | aacbb | 预测无附加操作 |
| ‡$R⊥_α R⊥_β FA$ | ‡B | aacbb | 在$β$中向下移动 |
| ‡$R⊥_α R⊥_β F$ | ‡B | acbb | 扫描$a$ |
| ‡$R⊥_α R⊥_β$ | ‡B | acbb | 离开$β$ |
| ‡$R⊥_α FA$ | ‡BB | acbb | 在$β$中向下移动 |
| ‡$R⊥_α F$ | ‡BB | cbb | 扫描$a$ |
| ‡$R⊥_α$ | ‡BB | cbb | 离开$β$ |
| ‡C | ‡BB | cbb | 在$α$中向下移动 |
| ‡ | ‡BB | bb | 扫描$c$ |
| ‡ | ‡B | b | 扫描$b$ |
| ‡ | ‡ | ε | 扫描$b$ |

通过这个示例，我们可以看到双栈自动机如何根据输入和栈内容进行状态转移，从而实现对语言结构的处理。

2. 强驱动双栈自动机（SD - 2SA）

强驱动双栈自动机是双栈自动机的一种变体，旨在为树邻接语法（TAG）和线性索引语法（LIG）提供一种优雅的解析策略表示。

2.1 工作原理

SD - 2SA的核心思想是为两个栈分配不同的角色：
- 主栈（MS） ：用于大部分操作。
- 辅助栈（AS） ：用于“记账”，是一个会话栈的栈，在任何时刻，只能访问最顶层的栈。

SD - 2SA具有线性行为，在每个会话中，首先处于“写入”模式，将元素压入主栈；然后切换到“擦除”模式，从主栈中弹出元素。一旦进入擦除模式，在同一会话中不能再返回写入模式。会话结束的条件是处于擦除模式，辅助栈的顶层会话栈为空，且主栈中包含启动该会话的元素。

2.2 定义

一个强驱动双栈自动机$M$是一个元组$⟨Σ, M, X, $0, $f, Θ⟩$，其中：
- $Σ$：有限的终结符集合。
- $M$：主栈元素的有限集合。
- $X$：辅助栈元素的有限集合。
- $ $0, $f ∈M$：两个特殊的主栈元素，分别为初始符号和最终符号。
- $Θ$：有限的转移集合。

主栈由$M$中的元素组成，每个元素前面都有一个动作标记。动作标记集合$D = {↗, ↘, →, |= }$，其含义如下：
- $↗$：表示一个元素已被压入辅助栈。
- $↘$：表示一个元素已从辅助栈弹出。
- $→$：表示在辅助栈上未执行任何操作。
- $|=$：表示启动了一个新的会话，将一个新的空会话栈压入辅助栈。

辅助栈上，新会话的启动用$|=w$或$|=e$标记，分别表示会话以写入或擦除模式启动。

SD - 2SA的一个配置是一个元组$(m, i, M, A)$，其中$m ∈{w, e}$是当前模式，$i$是当前输入位置，$M$和$A$分别是主栈和辅助栈。初始配置是$(w, 0, |= $0, |=w)$，最终配置是$(e, n, |= $f, |=w)$，其中$n$是输入的长度。

2.3 复杂度

Villemonte de la Clergerie和Pardo（1998）提出了一种使用所谓的转义上下文无关推导的子推导紧凑表示方法，实现了SD - 2SA的表格化，从而达到了$O(n^6)$的时间复杂度和$O(n^5)$的空间复杂度。

3. 线程自动机（TA）

线程自动机是一种强大的自动机模型，由Villemonte de la Clergerie（2002）提出，可接受所有局部上下文自由递归语言（LCFRL）。

3.1 基本思想

线程自动机的总体思想是拥有一组线程，其中一个是活动线程。每个线程都有一个唯一的路径，用于在树形线程结构中定位。当启动一个新线程时，其路径是父线程路径和一个新符号的连接。自动机的移动包括：
- 更改活动线程的内容。
- 启动一个新的子线程。
- 移动到现有的子线程。
- 移动到父线程，同时可能终止活动线程。

以树邻接语法（TAG）为例，在对应的线程自动机中，每个推导的基本树都有一个线程，线程的内容是该基本树中的一个带点节点。当预测附加操作时，启动一个子线程；当到达脚节点的左侧时，暂停子线程并返回父线程；当到达父线程中附加位点下方部分的右侧时，继续附加树的子线程，直到辅助树完全遍历后终止该子线程，然后返回父线程。

线程自动机提供了以下操作：
- SWAP ：更改活动线程的内容，同时可能扫描一个终结符。
- PUSH ：创建一个新的子线程，同时暂停其父线程。
- POP ：结束活动线程，将控制权返回给其父线程。
- SPUSH ：恢复一个暂停的子线程。
- SPOP ：恢复活动线程的父线程，同时更改其父线程的内容。

以下是一个线程自动机处理TAG的示例运行过程：

graph LR
    classDef startend fill:#F5EBFF,stroke:#BE8FED,stroke-width:2px;
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;
    A([1 : •Rα]):::startend -->|PUSH| B([1 : •Rα], [11 : •Rβ]):::process
    B -->|PUSH| C([1 : •Rα], [11 : •Rβ], [111 : •Rβ]):::process
    C -->|SWAP| D([1 : •Rα], [11 : •Rβ], [111 : •a]):::process
    D -->|SWAP (scan a)| E([1 : •Rα], [11 : •Rβ], [111 : a•]):::process
    E -->|SWAP| F([1 : •Rα], [11 : •Rβ], [111 : •F]):::process
    F -->|SPOP| G([1 : •Rα], [11 : •a], [111 : •F]):::process
    G -->|SWAP| H([1 : •Rα], [11 : a•], [111 : •F]):::process
    H -->|SWAP (scan a)| I([1 : •Rα], [11 : •F], [111 : •F]):::process
    I -->|SPOP| J([1 : •c], [11 : •F], [111 : •F]):::process
    J -->|SWAP (scan c)| K([1 : c•], [11 : •F], [111 : •F]):::process
    K -->|SWAP| L([1 : Rα•], [11 : •F], [111 : •F]):::process
    L -->|SPUSH| M([1 : Rα•], [11 : F •], [111 : •F]):::process
    M -->|SWAP| N([1 : Rα•], [11 : •b], [111 : •F]):::process
    N -->|SWAP (scan b)| O([1 : Rα•], [11 : b•], [111 : •F]):::process
    O -->|SWAP| P([1 : Rα•], [11 : Rβ•], [111 : •F]):::process
    P -->|SPUSH| Q([1 : Rα•], [11 : Rβ•], [111 : F •]):::process
    Q -->|SWAP| R([1 : Rα•], [11 : Rβ•], [111 : •b]):::process
    R -->|SWAP (scan b)| S([1 : Rα•], [11 : Rβ•], [111 : b•]):::process
    S -->|SWAP| T([1 : Rα•], [11 : Rβ•], [111 : Rβ•]):::process
    T -->|SWAP| U([1 : Rα•], [11 : Rβ•], [111 : ret]):::process
    U -->|POP| V([1 : Rα•], [11 : ret]):::process
    V -->|SWAP| W([1 : Rα•]):::process
    W -->|POP| X([1 : ret]):::startend

通过这个示例，我们可以直观地看到线程自动机如何通过线程的创建、暂停和恢复来处理语言结构。

3.2 一般定义

一个线程自动机$M$是一个元组$⟨N, T, S, F, κ, K, δ, U, Θ⟩$，其中：
- $N$和$T$：分别是非终结符和终结符的字母表，$S, F ∈N$是起始和结束符号。
- $κ$：触发函数，是从$N$到某个有限集合$K$的部分函数。
- $U$：用于标识线程的有限标签集合。
- $δ$：从$N$到$U ∪{⊥}$的部分函数，用于指定在某些点可以创建或恢复的线程。
- $Θ$：有限的转移集合。

线程是一个对$p : A$，其中$p ∈U∗$是线程路径，$A ∈N$是线程的内容。线程存储是一组线程的集合，其地址在前缀下是封闭的。自动机的一个配置是一个元组$⟨i, p, S⟩$，其中$i$是输入位置，$S$是线程集合，$p$是$S$中的线程路径。

转移集合$Θ$中的转移有以下几种形式：
- SWAP操作 ：$B \stackrel{α}{\rightarrow} C$，其中$B, C ∈N$，$α ∈T ∗$。
- PUSH操作 ：$b \rightarrow [b]C$，其中$b ∈K$，$C ∈N$。
- POP操作 ：$[B]C \rightarrow D$，其中$B, C, D ∈N$。
- SPUSH操作 ：$b[C] \rightarrow [b]D$，其中$b ∈K$，$C, D ∈N$。
- SPOP操作 ：$[B]c \rightarrow D[c]$，其中$c ∈K$，$B, D ∈N$。

线程自动机的语言定义为从初始线程集合${ε : S}$开始，在扫描完整个输入后能够到达集合${ε : S, δ(S) : F}$的所有单词的集合。

通过以上介绍，我们详细了解了双栈自动机、强驱动双栈自动机和线程自动机的工作原理、定义和应用。这些自动机模型在自然语言处理和计算理论中具有重要的应用价值，能够帮助我们处理和识别各种复杂的语言结构。

自动机模型：从双栈自动机到线程自动机

3.3 为树邻接语法（TAG）构建线程自动机

为图中所示的TAG构建线程自动机时，与前面示例的线程集有一个细节不同，即添加了一个额外符号$S$，起始线程为$ε : S$，该线程会启动一个子线程$1 : •Rα$。在最终配置中，会得到线程$ε : S$和$1 : ret$，这符合线程自动机语言的定义。

线程自动机$M = ⟨N, T, S, ret, κ, K, δ, U, Θ⟩$的具体定义如下：
- 非终结符集合$N$ ：包含所有形如$•X$、$•X$、$X•$、$X•$的符号，其中$X$是基本树中的节点，即$X ∈{Rα, c, Rβ, a, F, b}$，此外还包含特殊符号$ret$和$S$。
- 终结符集合$T$ ：$T = {a, b, c}$。
- 起始和结束符号 ：$S$是初始线程符号，$ret$是最终线程符号。
- 触发函数$κ$和集合$K$ ：$K = N$，对于所有$A ∈N$，$κ(A) = A$。
- 标签集合$U$和函数$δ$ ：$U = {1}$，对于所有$A ∈N \setminus {•F, ret}$，$δ(X) = 1$；$δ(ret) = ⊥$，$δ(•F) = ⊥$。
- 转移集合$Θ$ ：
- $S →[S]•Rα$：启动初始树。
- $•Rα →•Rα$，$•Rβ →•Rβ$：预测无附加操作。
- $•Rα →•c$，$•Rβ →•a$：向下移动。
- $•c \stackrel{c}{\rightarrow} c•$，$•a \stackrel{a}{\rightarrow} a•$，$•b \stackrel{b}{\rightarrow} b•$：扫描。
- $a• →•F$，$F • →•b$：向右移动。
- $c• →Rα•$，$b• →Rβ•$：向上移动。
- $Rα• →Rα•$，$Rβ• →Rβ•$：若没有附加操作则向上移动。
- $•Rα →[•Rα]•Rβ$，$•Rβ →[•Rβ]•Rβ$：预测附加树。
- $[•Rα]•F →•Rα[•F]$，$[•Rβ]•F →•Rβ[•F]$：回到附加位点。
- $Rα•[•F] →[Rα•]F •$，$Rβ•[•F] →[Rβ•]F •$：恢复附加树。
- $Rα• →ret$，$Rβ• →ret$：完成基本树。
- $[Rα•]ret →Rα•$，$[Rβ•]ret →Rβ•$：终止附加操作，返回。

在这个线程自动机中，父线程总是唯一确定的，并且在完成脚节点下方的部分后，附加树的线程由附加位点的$δ$值确定。每个树中的每个附加位点都必须有唯一的$δ$值。该线程自动机模拟了自顶向下的识别过程，对派生树进行自顶向下、从左到右的遍历。

3.4 为有序简单线性上下文无关重写系统（SRCG）构建线程自动机

为有序简单SRCG构建线程自动机的总体思路是模拟自顶向下、从左到右的前缀有效识别，类似于增量Earley解析。

3.4.1 具体构建

线程设置 ：为每个处理的子句设置一个线程，从SRCG的起始谓词的某个S - 子句开始。对于每个新预测的子句，启动一个线程，该线程将遍历子句的整个左侧。
符号引入 ：为了跟踪在子句左侧参数内的位置，引入新符号$c_{k,i}$，表示即将处理子句$c$的第$k$个参数的第$(i + 1)$个元素。
标签集合$U$ ：$U = {1, \ldots, m}$，其中$m$是SRCG子句中右侧谓词的最大数量，子线程的地址表示对应于该子线程的右侧元素。
集合$K$和函数$κ$、$δ$ ：$K = N ∪{void}$，具体定义如下：
- 若$A$是子句$c$右侧的第$j$个谓词，且$c(k, i + 1)$是其第一个参数，则$κ(c_{k,i}) = A$且$δ(c_{k,i}) = j$。
- 若$c(k, i + 1)$是子句$c$右侧第$j$个谓词的参数但不是其第一个参数，则$κ(c_{k,i}) = void$且$δ(c_{k,i}) = j$。
- 若$c(k, i + 1)$不存在，即到达第$k$个参数的末尾，则$κ(c_{k,i}) = void$且$δ(c_{k,i}) = ⊥$。
起始和结束符号 ：最终线程符号为$ret$，$δ(ret) = ⊥$；起始符号为新符号$S′$，$δ(S′) = 1$，最终配置必须包含线程集${ε : S′, 1 : ret}$。

3.4.2 示例分析

线程自动机的转移如下：
- 调用（Call） ：
- $S′ →[S′]S$（初始调用）。
- 若$κ(γ_{k,i}) = A$，则$γ_{k,i} →[γ_{k,i}]A$。
- 预测（Predict） ：
- $A →γ_{1,0}$，对于所有$A$ - 子句$γ$。
- 扫描（Scan） ：
- 若$γ(k, i + 1)$是终结符，则$γ_{k,i} \stackrel{γ(k,i + 1)}{\rightarrow} γ_{k,i + 1}$。
- 发布（Publish） ：
- 若子句$γ$左侧谓词的元数为$k$，且左侧的第$k$个参数长度为$j$，则$γ_{k,j} \stackrel{ε}{\rightarrow} ret$。
- 暂停（Suspend） ：
- 若$γ(k, i + 1)$是子句$γ$右侧某个谓词的最后一个参数，则$[γ_{k,i}]ret →γ_{k,i + 1}$。
- 若$γ(k, i + 1)$是变量$X$，$β$是$B$ - 子句，$X$是$γ$右侧$B$的第$l$个参数但不是其最后一个参数，且$β$左侧的第$l$个参数长度为$j$，则$[γ_{k,i}]β_{l,j} →γ_{k,i + 1}[β_{l,j}]$。
- 恢复（Resume） ：
- 若$γ(k, i + 1)$是变量$X$，$β$是$B$ - 子句，$X$是$γ$右侧$B$的第$(l + 1)$个参数，且$β$左侧的第$l$个参数长度为$j$，则$γ_{k,i}[β_{l,j}] →β_{l + 1,0}$。

示例运行过程如下：

graph LR
    classDef startend fill:#F5EBFF,stroke:#BE8FED,stroke-width:2px;
    classDef process fill:#E5F6FF,stroke:#73A6FF,stroke-width:2px;
    A([ε : S′]):::startend -->|初始化| B([ε : S′, 1 : S]):::process
    B -->|预测| C([ε : S′, 1 : α1,0]):::process
    C -->|调用| D([ε : S′, 1 : α1,0, 11 : A]):::process
    D -->|预测| E([ε : S′, 1 : α1,0, 11 : β1,0]):::process
    E -->|扫描| F([ε : S′, 1 : α1,0, 11 : β1,1]):::process
    F -->|调用| G([ε : S′, 1 : α1,0, 11 : β1,1, 111 : A]):::process
    G -->|预测| H([ε : S′, 1 : α1,0, 11 : β1,1, 111 : γ1,0]):::process
    H -->|扫描| I([ε : S′, 1 : α1,0, 11 : β1,1, 111 : γ1,1]):::process
    I -->|暂停| J([ε : S′, 1 : α1,0, 11 : β1,2, 111 : γ1,1]):::process
    J -->|暂停| K([ε : S′, 1 : α1,1, 11 : β1,2, 111 : γ1,1]):::process
    K -->|恢复| L([ε : S′, 1 : α1,1, 11 : β2,0, 111 : γ1,1]):::process
    L -->|扫描| M([ε : S′, 1 : α1,1, 11 : β2,1, 111 : γ1,1]):::process
    M -->|恢复| N([ε : S′, 1 : α1,1, 11 : β2,1, 111 : γ2,0]):::process
    N -->|扫描| O([ε : S′, 1 : α1,1, 11 : β2,1, 111 : γ2,1]):::process
    O -->|暂停| P([ε : S′, 1 : α1,1, 11 : β2,2, 111 : γ2,1]):::process
    P -->|暂停| Q([ε : S′, 1 : α1,2, 11 : β2,2, 111 : γ2,1]):::process
    Q -->|恢复| R([ε : S′, 1 : α1,2, 11 : β3,0, 111 : γ2,1]):::process
    R -->|扫描| S([ε : S′, 1 : α1,2, 11 : β3,1, 111 : γ2,1]):::process
    S -->|恢复| T([ε : S′, 1 : α1,2, 11 : β3,1, 111 : γ3,0]):::process
    T -->|扫描| U([ε : S′, 1 : α1,2, 11 : β3,1, 111 : γ3,1]):::process
    U -->|发布| V([ε : S′, 1 : α1,2, 11 : β3,1, 111 : ret]):::process
    V -->|暂停| W([ε : S′, 1 : α1,2, 11 : β3,2]):::process
    W -->|发布| X([ε : S′, 1 : α1,2, 11 : ret]):::process
    X -->|暂停| Y([ε : S′, 1 : α1,3]):::process
    Y -->|发布| Z([ε : S′, 1 : ret]):::startend

通过这个示例可以看到，线程自动机如何根据不同的操作（调用、预测、扫描、暂停、恢复、发布）在不同的线程之间切换，从而实现对SRCG的识别。

综上所述，双栈自动机、强驱动双栈自动机和线程自动机在自然语言处理和计算理论中都有着重要的应用。线程自动机作为最强大的自动机模型，能够接受所有LCFRL，并且通过合理的构建和优化，可以实现对复杂语言结构的高效处理和识别。不同的自动机模型适用于不同的场景，在实际应用中需要根据具体需求进行选择和使用。