证明图灵机计入O（n）？

Question

因此，在过去的几天里，我一直在设计Turing Machine，发现在实现过程中，我对二进制文件的计数大约为4n，其中n是我要计数的数字。 所以O（4n）-> O（n） 我不太擅长证明复杂性，但是从研究中我了解到，如果您有图灵机M，则{0,1} *中的每n个，t_ {M}（n）将持续多长时间需要数到n，对吗？ 然后，如果不停止，则它的最高界限是无穷大。 有没有办法在这两者之间架起桥梁，得出结论，有n个台阶确实是最坏的情况？ 我永远不知道从哪里开始打样，有什么想法吗？

更新：

以下是我的图灵机表示形式，用于二进制计数：

import java.util.Scanner;
public class TuringMachine {

/**
 * Divide a number n by 2 shifting right (shift-right-logical) 
 * to figure out the minimum number of bits needed to represent
 * the number in binary.
 */
private static int getNumBits(int n) {
    int c = 0;
    while (n > 0) {
        c++;
        n = n >> 1;
    }
    return c;
}

private static void computeBinaryValues(int n) {
    System.out.println();

    int i, c, state;
    char symbol;
    String t;

    System.out.println("Computed binary values for:"); 

    // Compute values of n = 1 to n  
    for (int j = 1; j <= n; j++) {
        t = ""; // temp string
        state = 0; // current state
        symbol = ' '; // current symbol being read
        c = getNumBits(j) + 1; // minimum number of bits needed + 1 for a buffer
        i = c - 1; // indexing starting from end of the string 

        // initialize temp string to contain all ' ' characters
        for (int k = 0; k < c; k++) {
            t += " ";
        }

        // String builder off "empty" t string 
        StringBuilder s = new StringBuilder(t);
        // The actual binary representation of n + end space buffer
        String a = Integer.toBinaryString(j) + " ";

        // Turing Cycle  
        while (!(s.toString()).equals(a)) { // if the binary build is successful, these match.
            if (state == 0) {
                if (symbol == ' ') {
                    state = 1;
                    i--; // left
                } else { // symbols 0 and 1 rewrite themselves && move right 1
                    i++; // right
                } 
            } else if (state == 1) {
                if (symbol == ' ') {
                    s.setCharAt(i, '1');
                    state = 0;
                    i++; // right
                } else if (symbol == '0') {
                    s.setCharAt(i, '1');
                    state = 0;
                    i++; // right
                } else {
                    s.setCharAt(i, '0');
                    i--; // left
                }
            }
            symbol = s.charAt(i); // get symbol to read from
        }
        System.out.println(j + " -> " + s); // print binary string created from machine
    }
}

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    System.out.println("Enter value for n >= 1: ");;
    computeBinaryValues(in.nextInt());
}
}

因此，使用Ishtar的建议进行归纳：

C(0) = a C(1) = b C(2) = c

令k为常数-根据我的代码实验得出的假设为4。

c = k + b b = k + a

他说我们必须证明c(i+1) = c(i) + k然后我才解释了这是什么意思？ （我不理解他的归纳理由）

Answer 1

如果我正确地理解了您的问题，那么您正在尝试确定您的图灵机是否停止运行，以及是否没有，最糟糕的时间复杂度是无限的对吗？ 如果这是您的问题，那么不能在两者之间架起一座桥梁，为什么呢？ 因为停止问题（确定程序是否停止的问题）在机器上无法确定，这意味着不存在用于确定是否停止TM的算法（并且永远不会存在）。

Answer 2

证明您的机器以O（n）运行的一种方法是归纳证明。 （由于我不知道您的机器是什么样，所以我不能告诉您这是否是您的机器的正确方法。）将c(n)定义为机器计算长度的输入磁带所需的步数n 。 （或者您在数什么？）现在尝试证明：

1. c（0）= k
2. c（1）= l
3. c（2）= m

如果确实以4n步长运行，则m = 4 + l和l = 4 + k 。 现在最难的部分证明

1. c（i + 1）= c（i）+ 4

然后我们可以根据证明c(0) = k和c(i+1) = c(i) + 4得出结论，对于所有n>=0 ， c(n) = 4*n + k 。 因为c(n) = O(4n) = O(n)所以机器以O（n）运行。

（您还应证明机器始终会终止并给出正确的结果，但这可能超出范围。）

---

更新：

因此，您的机器实际上并没有计算任何东西。 它永远运行，写入所有二进制数字。 如果Java程序输入了输入数字，它将停止机器，机器本身将永远运行，对吗？

让我们将机器成功写入数字的点定义为：state = 0且在读取input ='blank'之前。 同意？

将c(n)定义为步数，机器需要写n ，（因此状态= 0，输入='空白'，并且n的二进制表示形式写在磁带上）。 现在，尝试证明c(0) = k ， c(1) = l和c(2) = m 。 k，l和m的实际值！ 例如c(0) = 2 ， c(1) = 8 ？ （我没有尝试这些值。）只需逐步跟踪机器并计数。

您真正需要证明的是c(i+1) = c(i) + something 。 然后，您可以将c(i)求解为封闭形式。 可以这样想，如果在磁带上写了111 （状态= 0，下一个输入='空白'），则机器要经过多少步才能写入1000 （状态= 0，下一个输入='空白”）：4、5、6、7、8或...？