【系统分析与验证笔记】Transition System模型知识点

项目到模型的转换原因

当我们需要对一个项目进行验证时，我们无法对该项目直接验证，而是要转换成可以做验证的模型，比如一个C语言程序，要先将它转换为一阶逻辑公式，再将一阶逻辑公式转换为Kripke结构，之后我们才能进行验证分析，得到我们所需的结论。

本章基本词汇解释

• State（状态）：系统在某一时刻的特性，也值程序中所有变量的值。例如：交通灯的红色、黄色、绿色。

• Transition（转换/转移/迁移）：指从一个状态到另一个状态的演化。例如：交通灯由红色变为黄色。

  在程序中，可以理解为

  • 当前时刻：{x=1,y=2}
  • 执行变迁：x=5,y=x+1
  • 下一时刻：{x=5,y=6}

• Action（动作）：过程之间的沟通机制。

• Atomic Propositions（原子命题）：形式化临时特征。原子表示不可再分，命题表示这是具有判断能力的陈述句。例如：X=1；店里没有顾客。

• Kripke Structure（状态迁移系统）：是一个基于原子命题AP的四元组，用$M$表示，$M=（S,S_0,R,L)$

  • $S$是有限状态集合
  • $S_0$是初始状态集合
  • $R$是状态之间的关系，如$R\subseteq S\times S$，表示状态之间所有的关系。(这里的$\times$表示笛卡尔积)
  • $L$是一个标签函数，状态到原子命题集合的一个函数，如 L ( s 0 ) = { a , b } L(s_0)=\{a,b\} L(s0​)={a,b}

• First order logic（一阶逻辑系统）：用一阶逻辑描述并发系统的状态，有四个属性：

  • V = { v 1 , ⋯   , v 1 } V=\{v_1,\cdots,v_1\} V={v1​,⋯,v1​}表示系统变量集合
  • $D$表示变量的有限域，比如布尔值变量的有限域为{true,false}
  • $A$表示变量$V$到有限域$D$的一个映射（也叫赋值）
  • $state$：使它为真的公式就是状态。比如$S=(v_1=2)\wedge (v_2=3)$，因为$v_1=2$和$v_2=3$都为真，所以$(v_1=2)\wedge (v_2=3)$也为真，因此$S$称之为状态。

  • 如果 D = { 2 , 3 , 4 , 5 } ， S = { ( v 1 = 2 ) ∧ ( v 2 = 3 ) ∧ ( v 3 ≠ 5 ) } D=\{2,3,4,5\}，S=\{(v_1=2)\wedge(v_2=3)\wedge(v_3\neq 5)\} D={2,3,4,5}，S={(v1​=2)∧(v2​=3)∧(v3​​=5)}，则该$S$其实表示了三个状态：
    • S 1 = { ( v 1 = 2 ) ∧ ( v 2 = 3 ) ∧ ( v 3 = 2 ) } S_1=\{(v_1=2)\wedge(v_2=3)\wedge(v_3 = 2 )\} S1​={(v1​=2)∧(v2​=3)∧(v3​=2)}
    • S 2 = { ( v 1 = 2 ) ∧ ( v 2 = 3 ) ∧ ( v 3 = 3 ) } S_2=\{(v_1=2)\wedge(v_2=3)\wedge(v_3 = 3 )\} S2​={(v1​=2)∧(v2​=3)∧(v3​=3)}
    • S 3 = { ( v 1 = 2 ) ∧ ( v 2 = 3 ) ∧ ( v 3 = 4 ) } S_3=\{(v_1=2)\wedge(v_2=3)\wedge(v_3 = 4 )\} S3​={(v1​=2)∧(v2​=3)∧(v3​=4)}
  • 状态之间的合并用$\cup$表示，如$S_1\cup S_2\cup S_3$
  • 并发系统以一阶逻辑系统公式进行转换的过程：
    • $V$表示当前的变量集合，$V^{\prime }$表示下一时刻变量的集合，如 V = { v 1 , v 2 , v 3 } V=\{v_1,v_2,v_3\} V={v1​,v2​,v3​}， V ′ = { v 1 ′ , v 2 ′ , v 3 ′ } V'=\{v_1',v_2',v_3'\} V′={v1′​,v2′​,v3′​}，$v1\leftarrow 2,v2\leftarrow 3,v3\leftarrow 5,v{1}^{\prime }\leftarrow 1,v{2}^{\prime }\leftarrow 5,v{3}^{\prime }\leftarrow 4$
    • 转移过程：$(v_1=2\wedge v_2=3\wedge v_3=5)\wedge (v_1^{\prime }=1\wedge v_2^{\prime }=5\wedge v_3^{\prime }=4)$

• Transition System（转换系统，简称TS）：是一个六元组，$TS=(S,Act,\to ,I,AP,L)$

  • $Act$是组动作的合集；
  • $\to$表示转换关系，$\to \subseteq S\ast Act\ast S$，是状态-动作-状态的转移关系集合；
  • $I$是一组初始状态，$I\supseteq S$；
  • $AP$是一组原子命题；
  • $L$是一个标签函数，$S\to 2^{AP}$；

如果状态集$S$、动作集$Act$、原子命题$AP$都是有限的，那么称这个$TS$是有限的。

基本动作的转移公式：$S\stackrel{\alpha }{\to }{S}^{\prime }$

• 含义： 动作$\alpha$将状态$S$转变为状态$S^{\prime }$。
• 备注：
  • $S$的下一个状态$S^{\prime }$是不确定的，只有经历了动作$\alpha$的转换，$S$的下一个状态$S^{\prime }$才被确定下来；
  • 当初始状态集包含超过1个状态时，初始状态$S$也是非确定的；
  • 动作是为通信建模而引入的机制，其它操作无需在意动作所执行的内容。

标签函数（Label function）：$L(s)\in 2^{AP}$

• 状态s满足命题逻辑公式Φ如果L(s)使公式Φ真；即$s\models \Phi iffL(s)\models \Phi$；
• 原子命题集合AP应当选择感兴趣的特征，也就是模型需要考虑的特征；
• 用法举例：L(select) = { paid }，表示在select状态时，取得的标签为paid。
• $L(s)\in 2^{AP}$其实就是$L(s)\subseteq AP$，原子性质集合

构建Kripke Sructure模型

需要根据程序的四个特征进行建模：顺序、分支、循环、并发

顺序程序（Sequential program）的建模

• 方法：对程序进行标签化
• 目的：将程序一条条处理
• 打标签的四个方法：
  • 如果是一条普通的语句P，则标签为：$P^L=P$
  • 如果是两条语句$P=P_1;P_2$，则标签为：$P^L=P_1^L;l^{\prime \prime }:P_2^L$
  • 如果是分支语句$P=ifbthen{P}_{1}else{P}_{2}endif$，则标签为：$P^L=ifbthen{l}_1:P_1^{L}else{l}_2:P_2^{L}endif$
  • 如果是循环语句$P=whilebdo{P}_{1}endwhile$，则标签为：$P^L=whilebdo{l}_1:P_1^{L}endwhile$
• 程序初始状态集合：$S_0(V,pc)\equiv pre(V)\wedge pc=m$

• $pre(V)$表示$V$的初始值，$pc$表示当前的语句入口，$p{c}^{\prime }$表示当前的语句出口，仅限于该条语句，而$m$表示程序的入口，$m^{\prime }$表示程序的出口，作用于整个程序（在后面的练习中可以深刻体会他们的区别）
• $\equiv$表示左右两侧的公式等价，所代表的含义相同，只不过表达方法不同而已

• 翻译过程：$C(l,P,l^{\prime })$表示程序入口为$l$，出口为$l^{\prime }$，程序要执行的语句为$P$，$C$表示这是一个要翻译的过程，翻译过程一般会有如下五种语句被翻译：

  • 赋值语句： C ( l , v ← e , l ′ ) ≡ p c = l ∧ p c ′ = l ′ ∧ v ′ = e ∧ s a m e ( V \ { v } ) C (l, v\leftarrow e, l' )\equiv pc=l \wedge pc'=l' \wedge v'=e \wedge same(V \backslash \{v\}) C(l,v←e,l′)≡pc=l∧pc′=l′∧v′=e∧same(V\{v})
  • 空语句：$C(l,skip,l^{\prime })\equiv pc=l\wedge p{c}^{\prime }=l^{\prime }\wedge same(V)$

  $skip$表示什么也不执行，空语句存在的目的是为了程序中对其语句等作用

  • 顺序语句：$C(l,P_1;l^{\prime \prime }:P_2,l^{\prime })\equiv C(l,P,l^{\prime })\vee C(l,P_2,l^{\prime })$
  • 条件语句：
    $$\begin{gathered} C(l,ifbthen{l}_1:P_{1}else{l}_2:P_{2}endif,l^{\prime })\equiv \\ (pc=l\wedge p{c}^{\prime }=l_1\wedge b\wedge same(V)) \\ \vee (pc=l\wedge p{c}^{\prime }=l_2\wedge \neg b\wedge same(V)) \\ \vee C(l_1,P_1,l^{\prime }) \\ \vee C(l_2,P_2,l^{\prime }) \end{gathered}$$
  • 循环语句：
    $$\begin{gathered} C(l,whilebdo{l}_1:P_{1}endwhile,l^{\prime })\equiv \\ pc=l\wedge p{c}^{\prime }=l_1\wedge b\wedge same(V)) \\ \vee pc=l\wedge p{c}^{\prime }=l_1\wedge \neg b\wedge same(V)) \\ \vee C(l_1,P_1,l) \end{gathered}$$

  • $same(V)$表示$V$中变量不发生变化
  • s a m e ( V \ { v } ) same(V \backslash \{v\}) same(V\{v})表示$V$中变量只有$v$发生变化
  • 有些地方用$l^{\prime },l^{\prime \prime }$有些地方用$l_1,l_2$的原因，个人感觉，应该是顺序语句用$l^{\prime },l^{\prime \prime }$，分支循环这种很多可能性的用$l_1,l_2$

• 练习题：对如下程序进行标签化
  V = { x , y , z } , i n i t i a l   v a l u e : x = y = z = 0 P r o g r a m : x = y + 1 ; z = z + 2 ; f o r ( y ; y < = 3 ; y + + ) i f   x < y   t h e n   x + + ; e l s e   y + + ; V=\{x,y,z\},initial \ value: x=y=z=0 \\ Program: \\ x=y+1; z=z+2;\\ for(y; y<=3; y++)\\ \quad if \ x<y \ then \ x++; else \ y++; V={x,y,z},initial value:x=y=z=0Program:x=y+1;z=z+2;for(y;y<=3;y++)if x<y then x++;else y++;

• 答案（答案不唯一）：

  • 初始化程序，先将程序标记分为三个标记语句
    $$\begin{gathered} P_1:x=y+1;z=z+2; \\ {P}_2:for(y;y<=3;y++) \\ {P}_3:ifx<ythenx++;elsey++; \end{gathered}$$
  • 对$P_1$继续标记：
    $$\begin{gathered} P_{11}:x=y+1 \\ {P}_{12}:z=z+2 \\ {P}_1^L=P_{11}^L;l_{12}=P_{12}^L \\ {P}_{11}^L=P_{11} \\ {P}_{12}^L=P_{12} \end{gathered}$$
  • 对$P_2$继续标记：
    首先将$for$语句转变为$while$语句
    $$\begin{gathered} y \\ while(y<=3) \\ do \\ {P}_3 \\ y++ \\ endwhile \end{gathered}$$
    然后进行标记
    $$\begin{gathered} P_{21}:y \\ {P}_{22}:y++ \\ {P}_2^L=P_{21}^L;l_{23}^{\prime \prime }=P_{23}^L \\ {P}_{21}^L=P_{21} \\ {P}_{22}^L=P_{22} \\ {P}_{23}^L=while(y<=3)do{l}_3:P_3^L;l_{22}:P_{22}^{L}endwhile \end{gathered}$$
  • 再对$P_3$进行标记：
    $$\begin{gathered} P_{31}:x++ \\ {P}_{32}:y++ \\ {P}_3^L:ifx<ythen{l}_{31}:P_{31}^{L}else{l}_{32}:P_{32}^{L}endif \\ {P}_{31}^L=P_{31} \\ {P}_{32}^L=P_{32} \end{gathered}$$
  • 由上述标记公式，可得一阶逻辑公式：
    • $x=0\wedge y=0\wedge z=0\wedge pc=m\wedge p{c}^{\prime }=l_{11}$
    • x ′ = y + 1 ∧ s a m e ( V \ { x } ) ∧ p c = l 11 ∧ p c ′ = l 12 x'=y+1 \wedge same(V \backslash \{x \}) \wedge pc=l_{11}\wedge pc'=l_{12} x′=y+1∧same(V\{x})∧pc=l11​∧pc′=l12​
    • z ′ = z + 2 ∧ s a m e ( V \ { z } ) ∧ p c = l 12 ∧ p c ′ = l 2 z'=z+2 \wedge same(V \backslash \{z \}) \wedge pc=l_{12}\wedge pc'=l_{2} z′=z+2∧same(V\{z})∧pc=l12​∧pc′=l2​
    • $y<=3\wedge same(V)\wedge pc=l_2\wedge p{c}^{\prime }=l_{21}$
    • $\neg (y<=3)\wedge same(V)\wedge pc=l_2\wedge p{c}^{\prime }=l_{22}$
    • $same(V)\wedge pc=l_{21}\wedge p{c}^{\prime }=l_3$
    • $same(V)\wedge pc=l_{22}\wedge p{c}^{\prime }=m^{\prime }$
    • $x<y\wedge same(V)\wedge pc=l_3\wedge p{c}^{\prime }=l_{31}$
    • $\neg (x<y)\wedge same(V)\wedge pc=l_3\wedge p{c}^{\prime }=l_{23}$
    • x ′ = x + 1 ∧ s a m e ( V \ { x } ) ∧ p c = l 31 ∧ p c ′ = l 23 x'=x+1 \wedge same(V \backslash \{x \}) \wedge pc=l_{31} \wedge pc'=l_{23} x′=x+1∧same(V\{x})∧pc=l31​∧pc′=l23​
    • y ′ = y + 1 ∧ s a m e ( V \ { y } ) ∧ p c = l 31 ∧ p c ′ = l 23 y'=y+1 \wedge same(V \backslash \{y \}) \wedge pc=l_{31} \wedge pc'=l_{23} y′=y+1∧same(V\{y})∧pc=l31​∧pc′=l23​
    • y ′ = y + 1 ∧ s a m e ( V \ { y } ) ∧ p c = l 23 ∧ p c ′ = l 2 y'=y+1 \wedge same(V \backslash \{y \}) \wedge pc=l_{23} \wedge pc'=l_{2} y′=y+1∧same(V\{y})∧pc=l23​∧pc′=l2​

IMP语言转一阶逻辑公式再转Kripke Structure程序

• IMP语法规则：
  • Aexp：$a::=n|x|a_0+a_1|a_0-a_1|a_0\times a_1,n\in [0,2]$
  • Bexp：$b::=true|false|a_0==a_1|a_0\le a_1|\neg b|b_0\wedge b_1|b_0\vee b_1$
  • Com：
    $$\begin{gathered} c::=cobeginp1||p2coend \\ p::=skip;|x:=a;|p_0;p_1|wait(b)|ifbthen{p}_{0}else{p}_1|whilebdop \end{gathered}$$
  • 整形变量取值范围：$[0,1,2]$
  • 布尔变量取值范围：$[0,1]$
  • 变量名规则：单个小写字母，如$a,b,c,\cdots$
• 样例1：
  • 输入IMP语言：
    $$\begin{gathered} x:=1; \\ y:=1; \\ x:=x+y; \end{gathered}$$
  • 输出一阶逻辑公式：
    D ≡ { 0 , 1 , 2 } V ≡ { x , y } S 0 ( x , y ) ≡ x = 1 ∧ y = 1 D\equiv \{0,1,2\}\\ V \equiv \{x,y\}\\ S_0(x,y)\equiv x=1 \wedge y =1 D≡{0,1,2}V≡{x,y}S0​(x,y)≡x=1∧y=1
    R ≡ x = 1 ∧ y = 1 ∧ p c = m ∧ p c ′ = l 1 x ′ = x + y ∧ s a m e ( V \ { x } ) ∧ p c = l 1 ∧ p c ′ = m ′ R\equiv\\ x=1∧y=1∧pc=m∧pc'=l1\\ x'=x+y∧same(V \backslash \{x\})∧pc=l1∧pc'=m' R≡x=1∧y=1∧pc=m∧pc′=l1x′=x+y∧same(V\{x})∧pc=l1∧pc′=m′
  • 输出Kripke Structure：
    $KS=(S,S_0,R,L)$
    S = { < 1 , 1 > , < 2 , 1 > } S=\{<1,1>,<2,1>\} S={<1,1>,<2,1>}
    S 0 = { < 1 , 1 > } S_0=\{<1,1>\} S0​={<1,1>}
    $R(x,y,x^{\prime },y^{\prime })\equiv x^{\prime }=(x+y)mod3\wedge y^{\prime }=y$
    L ( S 0 ) = { 1 , 1 } L(S_0)=\{1,1\} L(S0​)={1,1}
    L ( S 1 ) = { 2 , 1 } L(S_1)=\{2,1\} L(S1​)={2,1}
  • 输出Kripke Structure图形形式：
    
• 样例2：
  某大佬程序里直接跑的结果：
  
  
• 答案：
  一个大佬用python写的程序：https://github.com/lypnol/impy
  另一位大佬C++写的程序：https://git.code.tencent.com/fasasas/formal-IMP.git

  • 如果你是华师大郭老师的课程，这两个程序只能参考，千万别照搬，这俩郭老师都看过了，不要抱侥幸心理哦
  • 输入输出格式不唯一

并发程序（Concurrent programs）的建模

• 原因：由一组同时执行的进程组成，进程是顺序语句，我们假设CPU是单核的，所以程序只能异步执行，一次只能执行一条语句，所以我们要进行并发建模

• 组成：
  $V$：并发进程变量的集合
  $p{c}_i$：第$i$个并发进程
  $pc$：并发进程的计数器
  $PC$：并发进程的计数器的集合

• 表示方法：$P=Cobegin{P}_1||P_2||\cdots ||P_{n}coend$

• 标记并发程序：$P^L=conbegin{l}_1:P_1^L{l}_1^{\prime }||l_2:P_2^L{l}_2^{\prime }||\cdots ||l_n:P_n^L{l}_{n}coend$

• 并发程序初始状态：$S_0(V,pc)\equiv pre(V)\wedge pc=m\wedge \underset{i=1}{\stackrel{n}{\wedge }}(p{c}_i=\perp )$

• 并发程序执行过程： C ( m , c o n b e g i n   l 1 : P 1 L l 1 ′ ∣ ∣ l 2 : P 2 L l 2 ′ ∣ ∣ ⋯ ∣ ∣ l n : P n L   l n ′   c o e n d , m ′ ) ≡ ( p c = m ∧ ∧ n i = 1 ( p c i = ⊥ ) ∧ p c i = l 1 ∧ ⋯ ∧ p c n ′ = l n ∧ p c ′ = ⊥ ) ∨ ( p c = ⊥ ∧ p c 1 = l 1 ′ ∧ ⋯ ∧ p c n = l n ′ ∧ p c ′ = m ′ ∧ ∧ n i = 1 ( p c i ′ = ⊥ ) ) ∨ n i = 1 ( C ( l i , P i , l i ′ ) ∧ s a m e ( V \ V i ) ∧ s a m e ( P C \ { p c i } ) ) C (m, conbegin \ l_1:P_1^L l_1' || l_2:P_2^L l_2' || \cdots || l_n:P_n^L \ l_n' \ coend, m' ) \equiv \\ (pc = m \wedge \underset{i=1}{\overset{n}{\wedge}}(pc_i = \perp)\wedge pc_i=l_1\wedge \cdots\wedge pc_n' = l_n \wedge pc' = \perp)\\ \vee(pc=\perp\wedge pc_1=l_1' \wedge \cdots \wedge pc_n=l_n'\wedge pc'=m'\wedge \underset{i=1}{\overset{n}{\wedge}}(pc_i' = \perp))\\ \underset{i=1}{\overset{n}{\vee}}(C(l_i,P_i,l_i')\wedge same(V \backslash V_i)\wedge same(PC\backslash \{ pc_i \})) C(m,conbegin l1​:P1L​l1′​∣∣l2​:P2L​l2′​∣∣⋯∣∣ln​:PnL​ ln′​ coend,m′)≡(pc=m∧i=1∧n​(pci​=⊥)∧pci​=l1​∧⋯∧pcn′​=ln​∧pc′=⊥)∨(pc=⊥∧pc1​=l1′​∧⋯∧pcn​=ln′​∧pc′=m′∧i=1∧n​(pci′​=⊥))i=1∨n​(C(li​,Pi​,li′​)∧same(V\Vi​)∧same(PC\{pci​}))

  • $\perp$表示数值为空或否，$pc=\perp$表示程序未被激活
  • $\underset{i=1}{\stackrel{n}{\wedge }}(p{c}_i=\perp ))$表示$p{c}_1=\perp \wedge p{c}_2=\perp \wedge \cdots \wedge p{c}_n=\perp$

• 共享变量

  • 原因：当一个变量被一个进程访问时，其他变量如果想访问，需要将此变量共享才可以
  • 方法：
    • 等待：$$\begin{gathered} C(l,wait(b),l^{\prime })\equiv \\ (p{c}_i=l\wedge p{c}_i^{\prime }=l\wedge \neg b\wedge same(V_i)) \\ \vee (p{c}_i=l\wedge p{c}_i^{\prime }=l^{\prime }\wedge b\wedge same(V_i)) \end{gathered}$$
    • 加锁： C ( l , l o c k ( v ) , l ′ ) ≡ ( p c i = l ∧ p c i ′ = l ∧ v = 1 ∧ s a m e ( V i ) ) ∨ ( p c i = l ∧ p c i ′ = l ′ ∧ v = 0 ∧ v ′ = 1 ∧ s a m e ( V i \ { v } ) ) C(l,lock(v),l')\equiv \\ (pc_i=l \wedge pc_i'=l \wedge v=1 \wedge same(V_i))\\ \vee (pc_i=l \wedge pc_i'=l' \wedge v=0 \wedge v'=1 \wedge same(V_i \backslash \{v\})) C(l,lock(v),l′)≡(pci​=l∧pci′​=l∧v=1∧same(Vi​))∨(pci​=l∧pci′​=l′∧v=0∧v′=1∧same(Vi​\{v}))
    • 解锁：$$\begin{gathered} C(l,unlock(v),l^{\prime })\equiv \\ p{c}_i=l\wedge p{c}_i^{\prime }=l^{\prime }\wedge v^{\prime }=0\wedge same(V_i) \end{gathered}$$

• $P$初始状态：$S_0(V,pc)\equiv pc=m\wedge p{c}_0=\perp \wedge p{c}_1=\perp \wedge (turn=0\vee turn=1)$

• $P$的转移关系$$\begin{gathered} R(V,PC,V^{\prime },P{C}^{\prime })\equiv \\ (pc=m\wedge p{c}_0^{\prime }=l_0\wedge p{c}_1^{\prime }=l^{\prime }\wedge p{c}^{\prime }=\perp ) \\ \vee (pc=\perp \wedge p{c}_0=l_0^{\prime }\wedge p{c}_1=l_1^{\prime }\wedge p{c}^{\prime }=m^{\prime }\wedge p{c}_0^{\prime }=\perp \wedge p{c}_1^{\prime }=\perp ) \end{gathered}$$

并发还有没整理完，太多了，太难理解，以后有机会再整理

可满足性关系（Satisfaction relation）：$\models$

• 举个简单的例子：$\mu \models a>0ifa=1$，表示当a=1的时候，a>0的结果为true，最终$\mu \models$true，可满足性关系的式子成立。换句话说，就是当且仅当a=1时，$\mu$满足a>0（也就是$\mu \models true$）。
• true。此时$\mu \models$true也就是$\mu \models$后面的这个结果为true或，才表示可满足性关系。
• 专业解释：对原子命题集合AP的定值是将其映射到0或1上，即 $\mu ：AP\to \left\{\begin{array}{c}0,1\end{array}\right\}$，记Eval(AP)是AP内命题的全部的真值指派方式组成的集合。可满足关系$\models$是一个二元关系$(\mu ,\varphi )$，它指示的是在$\mu$这个定值方式下，命题逻辑公式$\varphi$的计算结果为真。
• 真值指派：此处可以理解成对变量的赋值影响相关原子命题的真值，例如设置a=2那么命题a>0的真值为真，将所有的命题计算得到的真假，即是对整个合取式的真值指派。
• 如果上面的文字还没能理解，那么我们再多举几个例子
  • $\mu \models true$
  • $\mu \models aiff\mu (a)=1$
  • $\mu \models {\varphi }_1\wedge {\varphi }_{2}iff\mu \models {\varphi }_{1}and\mu \models {\varphi }_2$

非确定性的应用（Application of nondeterministic）

• 通过两进程交替执行对独立活动的并行执行进行建模；
• 对两个进程访问同一共享资源而出现的复杂状况建模；
• 用于抽象的目的或者不规范的场景；
• 对未知或不可预测环境下的接口建模。
• 例题：
  • 向自动售货机内插入硬币后，可以选择购买啤酒或苏打水
    
  • S = { pay , select, soda, beer }
  • I = { pay }
  • Act = { insert_coin, get_soda, get_beer, $\tau$ }
  • 问题：请给出AP和L

---

  答案：
       AP = { paid , drink }
       L(pay) =  $\varnothing$
       L(soda) = L(beer) = { paid , drink }
       L(select) = { paid }

• 答案解析：paid表示投入了硬币，drink表示饮料取出喝掉，这两个状态的取值只能为真或假。一开始既没有付款也没有喝饮料，所以对pay取标签函数得到的是空集；在投入硬币进入select状态后，因为已经付款了，所以取标签得到的是{paid}；在出了饮料之后，即认为同时也可以喝了，所以取标签得到的是{paid,drink}。
• 这是一个非确定的系统，因为在投入硬币后，既可以选择提供啤酒，也可以选择提供苏打水。
• 当表示内部活动或者不相关活动时，使用一个特殊符号$\tau$
• Act 用于建模和数据通信
• AP的集合总是根据题目所需的特征来选择

从一阶逻辑公式构造Kripke structure(KS)例题

• 题目：
  • V = { x , y } V = \{ x,y \} V={x,y}
  • D = { 0 , 1 } D = \{ 0,1 \} D={0,1}
  • $S_0=(x,y)\equiv x=1\wedge y=1$
  • $Transition:$
    $R(x,y,x^{\prime },y^{\prime })\equiv x^{\prime }=(x+y)mod2\wedge y^{\prime }=y$
• 问题：
  • $KS=(S,S_0,R,L)$
• 解析：
  • 该系统的所有状态用$<x,y>$有序对来表示，而$x$和$y$的值域均为 D = { 0 , 1 } D=\{0,1\} D={0,1}，所以$<x,y>$的所有取值就是$D$和$D$的笛卡尔积来计算， S = D × D = { < 0 , 0 > , < 0 , 1 > , < 1 , 0 > , < 1 , 1 > } S=D×D=\{<0,0>,<0,1>,<1,0>,<1,1>\} S=D×D={<0,0>,<0,1>,<1,0>,<1,1>}
  • 按照描述，系统的初始状态集合为$S_0(x,y)\equiv x=1\wedge y=1$，所以初始状态 S 0 = { < 1 , 1 > } S_{0}=\{<1,1>\} S0​={<1,1>}
  • 我们需要从系统的每一个状态开始，分别计算经过转移后系统所达到的新状态。首先计算$x=0,y=0$的情况，一次转移后，即计算新的$x$和$y$值，得到$<(0+0)mod2,0>$，计算mod后结果为$<0,0>$，依次计算其余状态，我们可以得到$<1,0>\to <1,0>，<1,1>\to <0,1>,<0,1>\to <1,1>$，将其用$KS$的形式表示为 R = { ( < 0 , 0 > , < 0 , 0 > ) , ( < 1 , 0 > , < 1 , 0 > ) , ( < 0 , 1 > , < 1 , 1 > ) , ( < 1 , 1 > , < 0 , 1 > ) } R=\{(<0,0>,<0,0>),(<1,0>,<1,0>),(<0,1>,<1,1>),(<1,1>,<0,1>)\} R={(<0,0>,<0,0>),(<1,0>,<1,0>),(<0,1>,<1,1>),(<1,1>,<0,1>)}
  • 标签函数代表着某状态下取值为真的原子命题，即 L ( < 1 , 1 > ) = { x = 1 , y = 1 } ， L ( < 0 , 1 > ) = { x = 0 , y = 1 } ， L ( < 0 , 0 > ) = { x = 0 , y = 0 } ， L ( < 1 , 0 > ) = { x = 1 , y = 0 } L(<1,1>)=\{x=1,y=1\}，L(<0,1>)=\{x=0,y=1\}，L(<0,0>)=\{x=0,y=0\}，L(<1,0>)=\{x=1,y=0\} L(<1,1>)={x=1,y=1}，L(<0,1>)={x=0,y=1}，L(<0,0>)={x=0,y=0}，L(<1,0>)={x=1,y=0}

• ≡表示等同于，意思是执行S0(x,y)与执行x=1∧y=1的作用相同
• ∧表示左右两个式子同步执行，∨表示左右两个式子依次执行
• $S_0=(x,y)\equiv x=1\wedge y=1$表示初始状态下，$x$的值为1，y的值也为1
• $R(x,y,x^{\prime },y^{\prime })\equiv x^{\prime }=(x+y)mod2\wedge y^{\prime }=y$表示转移关系，$x^{\prime }$的值为$(x+y)mod2$，$y^{\prime }$的值仍然为y

• 图像表示为：
  

• 答案：

  • S = { { x = 1 ∧ y = 1 } , { x = 0 ∧ y = 1 } } S = \{\{x=1\wedge y=1\},\{x=0\wedge y=1\}\} S={{x=1∧y=1},{x=0∧y=1}}
  • S 0 = { { x = 1 ∧ y = 1 } } S_0 = \{\{x=1\wedge y=1\}\} S0​={{x=1∧y=1}}
  • R = { { x = 1 ∧ y = 1 ∧ x ′ = 0 ∧ y ′ = 1 } , { x = 0 ∧ y = 1 ∧ x ′ = 1 ∧ y ′ = 1 } } R = \{\{x=1\wedge y=1 \wedge x' = 0 \wedge y ' =1\},\{x=0\wedge y=1 \wedge x' = 1 \wedge y ' =1\}\} R={{x=1∧y=1∧x′=0∧y′=1},{x=0∧y=1∧x′=1∧y′=1}}
  • L ( S 0 ) = { x = 1 ∧ y = 1 } L(S_0) = \{x=1\wedge y=1\} L(S0​)={x=1∧y=1}
  • L ( S 1 ) = { x = 0 ∧ y = 1 } L(S_1) = \{x=0\wedge y=1\} L(S1​)={x=0∧y=1}

直接前驱和直接后继（Direct Predecessors and Successors expanded）

对于转换状态$TS=(S,Act,\to ,I,AP,L)$，如果$s\in S$且$\alpha \in Act$

• 一组$\alpha$的直接前驱定义为：
  $$Pre(s,\alpha )=\left\{\begin{array}{c}{s}^{\prime }\in S|s^{\prime }\stackrel{\alpha }{\to }s\end{array}\right\}$$
  $$Pre(s)=\bigcup _{\alpha \in Act}Pre(s,\alpha )$$

• 一组$\alpha$的直接后继定义为：
  $$Post(s,\alpha )=\left\{\begin{array}{c}{s}^{\prime }\in S|s\stackrel{\alpha }{\to }{s}^{\prime }\end{array}\right\}$$
  $$Post(s)=\bigcup _{\alpha \in Act}Post(s,\alpha )$$

• 直接前驱和直接后继者扩展到子集：
  $$Post(C,\alpha )=\bigcup _{s\in C}Post(s,\alpha )$$
  $$Post(C)=\bigcup _{s\in C}Post(s)$$
  $$Pre(C,\alpha )=\bigcup _{s\in C}Pre(s,\alpha )$$
  $$Pre(C)=\bigcup _{s\in C}Pre(s)$$

• 转换状态$TS$的终止状态：
  $$Post(C)=\varnothing$$

对于顺序计算机程序，终止状态表示程序的终；对于并行系统，终止状态通常被认为是不理想的。

确定性的转换系统（Deterministic Transition System）

• 关于action的确定转换系统
  • 对所有状态$s$和动作$\alpha$ ，都有
    $|I|⩽1and|Post(s,\alpha )|⩽1$
  • 表示任意状态经任意动作最多跳转到1个状态去
  • 这种系统叫做行动决定（action-deterministic）
• 关于AP的确定转换系统
  • 对所有状态$s$和AP的子集$A\in 2^{AP}$，都有
    $|I|⩽1and|Post(s)\cap \left\{\begin{array}{c}{s}^{\prime }\in S|L(s^{\prime })=A\end{array}\right\}⩽|1$
  • 表示从某一状态出发的直接后继，其Label函数的计算结果一定是不一样的
  • 这种系统叫做AP决定（AP-deterministic）

执行片段（Execution fragment）

• 对于转换状态$TS=(S,Act,\to ,I,AP,L)$，有两种执行片段
  • 有限执行片段
    • 公式：$\rho =s_0{\alpha }_1{s}_1{\alpha }_2...{\alpha }_n{s}_n$， 其中：对于所有的$0⩽i⩽n$，都有$s_i\stackrel{{\alpha }_{i+1}}{\to }{s}_{i+1}$
    • 公式含义：初始状态$s_0$，执行${\alpha }_1$后，状态变为$s_1$，执行${\alpha }_2$后，状态变为$s_2$……状态变为$s_{n-1}$，执行${\alpha }_n$后，状态变为$s_n$
  • 无限执行片段
    • 公式：$\rho =s_0{\alpha }_1{s}_1{\alpha }_2...$， 其中：对于所有的$0⩽i$，都有$s_i\stackrel{{\alpha }_{i+1}}{\to }{s}_{i+1}$
    • 公式含义：初始状态$s_0$，执行${\alpha }_1$后，状态变为$s_1$，执行${\alpha }_2$后，状态变为$s_2$……$

n表示有限片段的长度，n的值大于等于0

• 初始执行片段： 最大执行片段要么是以终止状态结束的有限执行片段，要么是无限执行片段。
• 最大执行片段：如果执行片段以初始状态启动，则称为初始片段。
• 执行状态：一个初始的、最大的执行片段。
• 可达状态：一个初始的、有限的执行片段。
  • 状态$s\in S$是可达的，意为存在这样的初始、有限的执行片段：$$s_0\stackrel{{\alpha }_1}{\to }{s}_1\stackrel{{\alpha }_2}{\to }...s_{n-1}\stackrel{{\alpha }_n}{\to }{s}_n=s$$
  • 记Reach(TS)表示TS中的可达状态集。