21计算理论

1 Regular Language and Finite Automata

1.1 Regular Expression:

只用字符和:

• *表示出现0到n次
• ()括号
• ∪
• 连接

表示的语言

使用并，连接和star对Regular expression进行构造仍然是正则语言

1.2 DFA:

1.消耗一个字符，转移一个状态

$(K,\Sigma ,\delta ,s,F)$

	含义
K	状态集合
$\Sigma$	字母表
$\delta$	转移函数：K*$\Sigma$->K
$s$	开始状态
F	结束状态

(q,w) |-M (q’,m’) 表示输入纸带w, 消耗后纸带w’，状态从q转移为q’

1.3 NFA:

$(K,\Sigma ,\delta ,s,F)$

	含义
K	状态集合
$\Sigma$	字母表
$\Delta$	转移函数：K* Σ ∪ { e } \Sigma\cup\{e\} Σ∪{e}*K
$s$	开始状态
F	结束状态

1.4 Closure properties and Pumping Theorem

对于DFA和NFA，接受的语言封闭：
1.Union,
2. 连接，
3. star,
4. 差集

Pumping theorem:
如果L是regular expression, 则L中的任意串都存在一种写法为w=xyz，满足
1 存在|xy|<n
2.y 不是e
3.xy^iz属于L

1.5 State Minimization

1.找到最终状态，分为两类
2.对于最终状态q, 输入a到达的状态归为一类，输入b到达的状态归为一类。
3.然后类似的操作。。。。
4.要求同一类的状态，输入a到达的是相同的类，输入b到达的是相同的类。

1.6 Give a DFA or NFA => Regular Expression

从DFA转为RE:
1.依次把非开始和非结束的状态q1,q2,…qn消除掉
2.消除q，
(1) 对于从q出去的路，考虑变为从q上一个状态到下一个状态连接
(2) 对于回到q的路径，考虑变为一个圈
(3) q上的圈变为star
(4) 如果两个状态之间超过2条路径，则使用∪

1.7 Give a Regular Expression => DFA or NFA

一般使用基本的几步操作：

Union：增加一个状态，n个转移
新增一个开始状态，用e连接到两个FA

连接: 新增0个状态，1个转移
前一个FA的终止状态通过e转移到后一个FA的开始状态

star：新增1个状态，n+1个转移
装新增一个开始终结状态，
两个转移：通过e转移到FA，FA的终结状态通过e转移到FA开始状态。

COmplementation(补集)
${\Sigma }^{\ast }$去减

交集：
状态变为2元组：(q1,q2)
转移函数变为：delta((q1,q2),a)=(delta1(q1,a),delta2(q2,a))

1.8 判断regular expression

Yes:
1.写出regular expression,
2.写出DFA, NFA
3.利用 closure property
No:
1.利用pumping theorem

如果证明不是Regular expression
1.先凑一个语言的串，比如a^nb^n
2.由于要求|xy|<N, 因此y=a，只能泵出a
3.说明泵出后的语言不属于原来的语言。

比如证明xx^R不是正则语言，则取x=aⁿbⁿ
由于|uv|<n, 因此v=a，而aⁿ⁺ⁱbⁿbⁿaⁿ
不满足L的条件，因此不是。
注意，此时检查的是是否满足语言的条件，而不是看是否满足aⁿbⁿ

2.利用closure property反证。

正则语言判断：
如果对于带n的，如果有直接的数值关系，比如n+1, n的倍数等等，泵的时候泵出带n的字符，此时一定不满足原来的关系。

如果是2k+1和2n, 它们有一定的关系，但是不是数值关系(和数的大小没有直接关系)因此泵的时候有时候也能成立。

1.有限个正则语言的并
2.可数无限个正则语言的并，不是，比如a^nb^n
3.可数有限个正则语言的交，是
4.subset 不是
5.对于x sigma* x^R, 就是sigma*
6.对于{a,b}^*, 先取空串试一下

1.9 DFA=>DFA

E(q)是从q出发，走e可以到达的状态

DFA转化为NFA:
K’={E(q), q in K}
s’=E(s)
F’为包含原来F中状态的所有状态
转移函数为q,a,q’变为所有E(q’)合起来。
相当于所有的状态都加上了e

时间复杂度是指数，因为状态变为了2^K个，K的幂集

常见的RE判断：
1.整除2，是(可以看最后一位数字是不是偶数)。
2.整除3，是(可以分为三个状态)。

2 Context-free Language and Pushdown Automata

2.1 Context-free Grammar

$(V,\Sigma ,R,s)$

	含义
V	字母表
$\Sigma$	终结符
S	开始符号
R	语法，(V-sigma) *V^*

推理的过程用${\to }_G$表示

aⁿbⁿ的R={S->aSb, S->e}
平衡括号：S->SS, S->(S), S->e
相等个数的ab: S->SS, S->aSb, S->bSa, S->e

2.2 Pushdown automata

PDA:
$(K,\Sigma ,\Gamma ,\Delta ,s,F)$
$\Gamma$是栈字母表，其他和NFA相同。
$\Delta$为K*(sigma cup {e})*gamma^* * (K * gamma*)

表示为: ((p,a,b),(q,c))
读入a, 从p->q, 将栈顶的b换成c

push a: (p,u,e), (q,a)
pop a: (p,u,a),(q,e)

被PDA接受的条件：(s,w,b) |-*M (p,e,e)
1.栈空
2.输入带空，
3.进入终止状态

注意：在delta中，表示的是消耗的字符，写入栈的字符，写出栈的字符
而在推导的过程中|-M，(q,a,b)表是的是输入带后面的所有字符，栈中所有的字符

2.3 Closure properties and Pumping Theorem

1.CFL在union, 连接，Star下封闭
2.CFL和Regular language 的交是CFL

Pumping threom:

对于w, 可以写为w=uvxyz 满足：
1.|vy>=1|
2.uvⁿxyⁿz 属于L, 对于所有的n>=0成立

当vy包含了所有字符时，假设v包含了a,b，则顺序错误
当vy没有包含所有字符时，则数量错误

一般来说是把vy放在一起讨论。

2.4 Give a context-free language => Context-free Grammar

一般把CFL看成基本的CFL的组合：
ww^R: S->aSa|bSb|e
aⁿb^m, n不等于m: S->aSb|aS2|bS3, S2->aS2|e, S3->bS3|e（在第一步增加相同个数的ab，之后只能增加a或者增加b）

例子：
xcy, |x|<=|y|<=3|x|, x,y in {a,b}*
S->xSx|xSxx|xSxxx|c
x->a|b

2.5 Give a context-free language => PDA

自己想象。
比如same number ab，则想象遇到a则入栈，遇到b则出栈一个a，直到结束。

K={s,q,f}
sigma ={a,b}
gamma={a,b,c}
F={f}
Delta:
((s,e,e),(q,c))
((q,a,e),(q,a))
((q,b,a),(q,e))
((q,e,c),(f,e))

2.6 Give a context-free grammar => PDA

K={p,q},
gamma=V,
delta:
1.写入S, ((p,e,e),(q,S))
2.每个规则进行推导，((q,e,A),(q,x)), for A->x
3.抵消终结符，((q,a,a),(q,e)), for all a in sigma

2.7 Show a given language be context-free or non-context free?

yes: 构造PDA，闭包性质
no: 通过反证法，用泵定理或者闭包性质

3 Turing Machine and Recursive Enumerable Language

3.1 Turing Machine

$(K,\Sigma ,\delta ,s,H)$

	含义
K	状态
$\Sigma$	字母表, 包含blank和left end, 不包含->和<-
$\delta$	非停机状态，读入一个字符，转移状态，写入一个字符或者←或者→
s	开始状态
H	停机状态

基本机器
a	写入a，停机
L	左移一格，停机
R	右移一格，停机
$R_{\bigsqcup }$	找到右边第一个空格
$R_{\bigsqcup ^{ˉ}}$	找到右边第一个非空格
$L_{\bigsqcup }$	找到左边第一个空格
$L_{\bigsqcup ^{ˉ}}$	找到左边第一个非空格

在箭头上方写上读入的字符，左右表示从一个机器停机，转移到下一个机器。

字符上方加横线表示非

3.2 Grammar

1.生成需要的字符，在最后的位置加上标记，
2.交换字符的位置，
比如aⁿbⁿcⁿ
S->ABCS，S->Tn
CB->BC, CA->AC, BA->AB
CTn->Tnc, BTn->Tnb, ATn->Tna
Tn->e

3.3 Numerical Functions

Basic Functions
1.zero(w)=0
2.$i{d}_{k,j}(n_1,...,n_k)=n_j$, 从k个参数中得到第j个
3.succ(n)=n+1
4.m~n=max{m-n, 0}
5.iszero(m)
6.greater-than-or-equal(m,n)
7.less-than(m,n)
8.如果case函数引用的函数都是recursive，则case也是recursive

composition:
函数嵌套，函数作为参数传入
function defined recursively:
函数递归，函数计算时调用了本身
primitiverecursive functions：
使用Basic 函数通过嵌套和递归组合成的函数。
primitive recursive predicate：
返回的是0,1值，相当于逻辑函数
minimalizable, μ-recursive

3.4 Design a Turing Machine to compute a function or decide (semidecide ) a language

decide: 停机状态分为y和n, 表示接受语言或者不接受，如果语言被接受就是递归的。

semidecides: 如果语言被接受，则图灵机停机。如果语言被接受，则是recursively enumerable.

图灵机不停机的方法：
1.不断消耗空格
2.进入死循环，比如使用左移函数。

可判定的性质：
1.递归语言的补集也是递归的
2.递归=>递归枚举
3.递归语言的交和并也是递归

3.5 Given a TM => function

3.6 Show a function be a primitive recursive function

一般分为递归和初始情况两种，注意乘号，除号，加号，整除号（n1 | n2 表示n1可以被n2整除），是否是质数(prime(n1)表示n1是否是质数)等都可以使用，说明两个问题：
1.说明n1+n2 is primitive，之类的，
2.说明函数是defined by recursive

4

1.是否接受w可能是半判定的，但是w是否可以使得M停机，是不可判定的。
2.为了说明某个问题是不是递归的，将该问题归约到在e上是否停机的问题：

1.挑选一个判断该问题的图灵机M*
2.构造一个图灵机M**
(1)先计算任意图灵机M是否在e上停机
(2)计算w是否被M*接受。
3.如果M在e上不停机，则L(M**)是空集
如果M在e上停机，则L(M**)=L(M*)，
因此判定L(M*)的图灵机也可以判定是否在e上停机，这和e停机问题不可判定是矛盾的。

其他

图灵机可计算<=>recursive<=>图灵字典序可枚举
图灵机半判定<=>recursive enumerate<=>图灵可枚举
图灵机停机问题是半判定的。
primitive recursive< recursive

	union	intersection	complement
regular	regular	regular	regular
contex free	contex free	no	no
recursive	recursive	recursive	recursive
recursive enumerate	r.e.	r.e.

regular<context free<recursive<recursive enumerate
primitive recursive和regular无法判断

1.对于语言的交并补是否是判定的，画韦恩图，然后考虑这种情况有没有机器停止，这种情况有没有机器停止。
L是递归可枚举的，L补是递归可枚举的<=>L是递归的

2.TM接受串的问题：接受n串可以看成接受一个串。把串一个一个送入，看是否接受。如果接受则停机。
at least 接受一个串：递归可枚举非递归
at most 接受一个串：非递归可枚举

3.一个语言是递归的 <=> 补语言是递归可枚举的。

归约<的性质：
1.后面的递归，前面递归
2.前面不递归，后面不递归

对于ww^R生成：

CFG: S->aSa|bSb|e
TM:
1.右移，读入a，如果a=空格，则y, a!=空格
2.写为空格，右移到最后一个空格
3.左移，读入，如果=a，则左移到空格，如果!=a则拒绝
4.回到1

对于|w|=3k的生成：

CFG: S->Sxxx|e, x->a|b
TM:
1.右移，读入a,b，如果是空格则y
2.右移，读入a,b, 如果空格则n
3.右移，读入a,b ，如果是空格则n
4.回到1