图灵机从 3 个字符的字母表中接受字符串

Question

我需要创建一个接受语言 a^1 b^j c^k where i >= j >= k 的图灵机，但我什至不确定如何开始。出于某种原因，在这种情况下，图灵机对我来说是一个难以理解的概念。

Answer 1

图灵机可以读写磁带，并在磁带上来回移动。如果你有一排三种颜色的弹珠，你会怎么看它们是否像你的语言中的字符串一样排列？您可以验证它们是否有序，然后分别计算每种颜色并确保关系成立。 “大于或等于”是一种二元关系，因此您可能会分别检查这两对。使用三个额外的磁带真的很容易想象：

1. 从左到右扫描以确保先出现 a，然后是 b，然后是 c，然后回到开头
2. 扫描右计数 a，在输入磁带上读取的每个 a 将一个 a 写入额外的磁带 #1
3. 使用额外的磁带 #2 继续扫描以计数 b
4. 使用额外的磁带 #3 继续扫描以计数 c
5. 重置所有磁头
6. 向右扫描以确保额外磁带 #1 中的内容比额外磁带 #2 中的内容多
7. 重置所有磁头
8. 向右扫描以确保额外的磁带 #2 比额外的磁带 #3 包含更多的东西

如果我们不想使用额外的磁带，我们该如何继续？好吧，我们可以先确保符号的顺序正确……让其余的更整洁。然后，我们可以“划掉” a 和 b 对，直到所有 b 都用尽（如果我们先用尽所有 a，则用 halt_reject）；然后，取消交叉 b 并交叉 b 和 c 对，直到你用完 c（如果你先用完 b，halt_reject）。比如……

 q    t    q'    t'    d

 q0   #    q1    #     right  //
 q1   a    q1    a     right  //
 q1   b    q2    b     right  //
 q1   #    q4    #     left   //
 q2   b    q2    b     right  // verify subset of
 q2   c    q3    c     right  // a*b*c*
 q2   #    q4    #     left   //
 q3   c    q3    c     right  //
 q3   #    q4    #     left   //

 q4   a    q4    a     left   //
 q4   b    q4    b     left   // reset input
 q4   c    q4    c     left   // tape to start
 q4   #    q5    #     right  //

 q5   a    q5    a     right  //
 q5   A    q5    A     right  // change susbtring a^j b^j
 q5   b    q6    B     left   // into substring A^j b^j
 q5   B    q5    B     right  // if run out of a, crash
 q5   c    q7    C     left   // if run out of b and no c, accept
 q5   #    h_a   #     left   // if run out of b and c, continue
 q6   a    q5    A     right  //
 q6   A    q6    A     left   //
 q6   B    q6    B     left   //

 q7   B    q8    D     right  //
 q7   C    q7    C     left   // change substring B^k c^k
 q7   D    q7    D     left   // to substring D^k c^k
 q8   D    q8    D     right  // if run out of B, crash
 q8   C    q8    C     right  // if run out of c, accept
 q8   c    q7    C     left   //
 q8   #    h_a   #     left   //

示例 1：aaabbc

   (q0, [#]aaabbc#) -> (q1, #[a]aabbc#) -> (q1, #a[a]abbc#) // 
-> (q1, #aa[a]bbc#) -> (q1, #aaa[b]bc#) -> (q2, #aaab[b]c#) // a*b*c*
-> (q2, #aaabb[c]#) -> (q3, #aaabbc[#]) -> (q4, #aaabb[c]#) //

-> (q4, #aaab[b]c#) -> (q4, #aaa[b]bc#) -> (q4, #aa[a]bbc#) //
-> (q4, #a[a]abbc#) -> (q4, #[a]aabbc#) -> (q4, [#]aaabbc#) // reset
-> (q5, #[a]aabbc#)                                         //

-> (q5, #a[a]abbc#) -> (q5, #aa[a]bbc#) -> (q5, #aaa[b]bc#) //
-> (q6, #aa[a]Bbc#) -> (q5, #aaA[B]bc#) -> (q5, #aaAB[b]c#) // a^j b^j
-> (q6, #aaA[B]Bc#) -> (q6, #aa[A]BBc#) -> (q6, #a[a]ABBc#) // A^j B^j
-> (q5, #aA[A]BBc#) -> (q5, #aAA[B]Bc#) -> (q5, #aAAB[B]c#) //
-> (q5, #aAABB[c]#) -> (q7, #aAAB[B]C#)                     //

-> (q8, #aAABD[C]#) -> (q8, #aAABDC[#]) -> (ha, #aAABD[C]#) // B^k c^k
                                                            // D^k C^k