Eu estava tentando explicar a alguém que C é Turing completo e percebi que na verdade não sei se é tecnicamente Turing completo. (C como na semântica abstrata, não como em uma implementação real.)

A resposta "óbvia" (grosso modo: ela pode endereçar uma quantidade arbitrária de memória, para emular uma máquina de RAM e, portanto, é completa em Turing) não é realmente correta, tanto quanto posso dizer, como se o padrão C permitisse para size_t ser arbitrariamente grande, ele deve ser fixado em algum comprimento e, independentemente do tamanho que for fixado, ele ainda é finito. (Em outras palavras, embora você possa, considerando uma máquina de Turing de parada arbitrária, escolher um tamanho_t de modo que ele funcione "corretamente", não há como escolher um tamanho_t de modo que todas as máquinas de Turing que parem funcionem corretamente)

Então: o C99 Turing está completo?

Não tenho certeza, mas acho que a resposta é não, por razões bastante sutis. Eu perguntei em Ciência da Computação Teórica há alguns anos e não obter uma resposta que vai além do que eu vou apresentar aqui.

Na maioria das linguagens de programação, você pode simular uma máquina de Turing:

• simulando o autômato finito com um programa que usa uma quantidade finita de memória;
• simulando a fita com um par de listas vinculadas de números inteiros, representando o conteúdo da fita antes e depois da posição atual. Mover o ponteiro significa transferir o cabeçalho de uma das listas para a outra lista.

Uma implementação concreta em execução em um computador ficaria sem memória se a fita ficasse muito longa, mas uma implementação ideal poderia executar o programa da máquina de Turing fielmente. Isso pode ser feito com caneta e papel ou comprando um computador com mais memória e um compilador visando uma arquitetura com mais bits por palavra e assim por diante, se o programa ficar sem memória.

Isso não funciona em C porque é impossível ter uma lista vinculada que pode crescer para sempre: sempre há algum limite no número de nós.

Para explicar o porquê, primeiro preciso explicar o que é uma implementação em C. C é realmente uma família de linguagens de programação. O padrão ISO C (mais precisamente, uma versão específica deste padrão) define (com o nível de formalidade que o inglês permite) a sintaxe e a semântica de uma família de linguagens de programação. C tem muitos comportamentos indefinidos e comportamentos definidos pela implementação. Uma "implementação" de C codifica todo o comportamento definido pela implementação (a lista de itens a serem codificados está no apêndice J da C99). Cada implementação de C é uma linguagem de programação separada. Observe que o significado da palavra “implementação” é um pouco peculiar: o que realmente significa é uma variante de linguagem, pode haver vários programas de compilação diferentes que implementam a mesma variante de linguagem.

Em uma determinada implementação de C, um byte possui valores possíveis de CHAR_BIT . Todos os dados podem ser representados como uma matriz de bytes: um tipo tem no máximo 2 CHAR_BIT × sizeof (t) valores possíveis. Esse número varia em diferentes implementações de C, mas para uma determinada implementação de C, é uma constante.$2^{\texttt{CHAR_BIT}}$t$2^{\texttt{CHAR_BIT} \times \texttt{sizeof(t)}}$

Em particular, os ponteiros podem ter no máximo . Isso significa que existe um número máximo finito de objetos endereçáveis.$2^{\texttt{CHAR_BIT} \times \texttt{sizeof(void*)}}$

Os valores de CHAR_BITe sizeof(void*)são observáveis; portanto, se você ficar sem memória, não poderá simplesmente continuar executando o programa com valores maiores para esses parâmetros. Você estaria executando o programa em uma linguagem de programação diferente - uma implementação em C diferente.

Se os programas em uma linguagem só podem ter um número limitado de estados, a linguagem de programação não é mais expressiva que os autômatos finitos. O fragmento de C restrito ao armazenamento endereçável permite apenas no máximo onde n é o tamanho da árvore de sintaxe abstrata do programa (representando o estado do fluxo de controle); programa pode ser simulado por um autômato finito com tantos estados. Se C é mais expressivo, deve ser através do uso de outros recursos.$n \times 2^{\texttt{CHAR_BIT} \times \texttt{sizeof(void*)}}$$n$

C não impõe diretamente uma profundidade máxima de recursão. É permitido que uma implementação tenha um máximo, mas também não é permitido. Mas como nos comunicamos entre uma chamada de função e seu pai? Os argumentos não são bons se forem endereçáveis, porque isso indiretamente limitaria a profundidade da recursão: se você tiver uma função int f(int x) { … f(…) …}, todas as ocorrências de xquadros ativos fterão seu próprio endereço e, portanto, o número de chamadas aninhadas será limitado pelo número de endereços possíveis para x.

O programa CA pode usar armazenamento não endereçável na forma de registervariáveis. As implementações “normais” podem ter apenas um número pequeno e finito de variáveis ​​que não têm um endereço, mas, em teoria, uma implementação pode permitir uma quantidade ilimitada de registerarmazenamento. Em tal implementação, você pode fazer uma quantidade ilimitada de chamadas recursivas para uma função, desde que seu argumento seja register. Mas, como os argumentos são register, você não pode fazer um ponteiro para eles e, portanto, precisa copiar explicitamente os dados deles: só é possível transmitir uma quantidade finita de dados, não uma estrutura de dados de tamanho arbitrário feita de ponteiros.

Com profundidade de recursão ilimitada e a restrição de que uma função pode obter apenas dados do chamador direto ( registerargumentos) e retornar dados ao chamador direto (o valor de retorno da função), você obtém o poder dos autômatos de empilhamento determinístico .

Não consigo encontrar um caminho a percorrer.

(É claro que você pode fazer com que o programa armazene o conteúdo da fita externamente, através das funções de entrada / saída de arquivo. Mas você não perguntaria se C é Turing-completo, mas se C mais um sistema de armazenamento infinito é Turing-completo, para qual a resposta é um chato "sim". Você também pode definir o armazenamento como um oráculo de Turing - chamada  fopen("oracle", "r+"), fwriteo conteúdo inicial da fita e freado conteúdo final da fita.)

A adição de C99 va_copyao API de argumento variado pode nos dar uma porta dos fundos para a integridade de Turing. Como é possível iterar por meio de uma lista de argumentos variados mais de uma vez em uma função diferente daquela que originalmente recebeu os argumentos, va_argspode ser usado para implementar um ponteiro sem ponteiro.

Obviamente, uma implementação real da API de argumento variável provavelmente terá um ponteiro em algum lugar, mas em nossa máquina abstrata ela pode ser implementada usando magia.

Aqui está uma demonstração implementando um autômato de empilhamento de 2 pilhas com regras de transição arbitrárias:

#include <stdarg.h>
typedef struct { va_list va; } wrapped_stack; // Struct wrapper needed if va_list is an array type.
#define NUM_SYMBOLS /* ... */
#define NUM_STATES /* ... */
typedef enum { NOP, POP1, POP2, PUSH1, PUSH2 } operation_type;
typedef struct { int next_state; operation_type optype; int opsymbol; } transition;
transition transition_table[NUM_STATES][NUM_SYMBOLS][NUM_SYMBOLS] = { /* ... */ };

void step(int state, va_list stack1, va_list stack2);
void push1(va_list stack2, int next_state, ...) {
    va_list stack1;
    va_start(stack1, next_state);
    step(next_state, stack1, stack2);
}
void push2(va_list stack1, int next_state, ...) {
    va_list stack2;
    va_start(stack2, next_state);
    step(next_state, stack1, stack2);
}
void step(int state, va_list stack1, va_list stack2) {
    va_list stack1_copy, stack2_copy;
    va_copy(stack1_copy, stack1); va_copy(stack2_copy, stack2);
    int symbol1 = va_arg(stack1_copy, int), symbol2 = va_arg(stack2_copy, int);
    transition tr = transition_table[state][symbol1][symbol2];
    wrapped_stack ws;
    switch(tr.optype) {
        case NOP: step(tr.next_state, stack1, stack2);
        // Note: attempting to pop the stack's bottom value results in undefined behavior.
        case POP1: ws = va_arg(stack1_copy, wrapped_stack); step(tr.next_state, ws.va, stack2);
        case POP2: ws = va_arg(stack2_copy, wrapped_stack); step(tr.next_state, stack1, ws.va);
        case PUSH1: va_copy(ws.va, stack1); push1(stack2, tr.next_state, tr.opsymbol, ws);
        case PUSH2: va_copy(ws.va, stack2); push2(stack1, tr.next_state, tr.opsymbol, ws);
    }
}
void start_helper1(va_list stack1, int dummy, ...) {
    va_list stack2;
    va_start(stack2, dummy);
    step(0, stack1, stack2);
}
void start_helper0(int dummy, ...) {
    va_list stack1;
    va_start(stack1, dummy);
    start_helper1(stack1, 0, 0);
}
// Begin execution in state 0 with each stack initialized to {0}
void start() {
    start_helper0(0, 0);
}

Nota: Se va_listfor um tipo de matriz, na verdade existem parâmetros de ponteiro ocultos para as funções. Portanto, provavelmente seria melhor alterar os tipos de todos os va_listargumentos para wrapped_stack.

Aritmética fora do padrão, talvez?

Então, parece que o problema é do tamanho finito de sizeof(t). No entanto, acho que conheço uma solução alternativa.

Até onde eu sei, C não requer uma implementação para usar os números inteiros padrão para seu tipo inteiro. Portanto, poderíamos usar um modelo aritmético não-padrão . Em seguida, sizeof(t)definiríamos um número fora do padrão e agora nunca o alcançaremos em um número finito de etapas. Portanto, o comprimento da fita das máquinas de Turing sempre será menor que o "máximo", pois o máximo é literalmente impossível de alcançar. sizeof(t)simplesmente não é um número no sentido regular da palavra.

Este é um tecnicismo, é claro: o teorema de Tennenbaum . Ele afirma que o único modelo de aritmética Peano é o padrão, o que obviamente não daria. No entanto, até onde eu sei, C não exige implementações para usar tipos de dados que satisfaçam os axiomas do Peano, nem exige que a implementação seja computável, portanto isso não deve ser um problema.

O que deve acontecer se você tentar gerar um número inteiro fora do padrão? Bem, você pode representar qualquer número inteiro fora do padrão usando uma sequência não padrão, portanto, basta transmitir os dígitos da frente dessa sequência.

Na IMO, uma forte limitação é que o espaço endereçável (através do tamanho do ponteiro) é finito e isso é irrecuperável.

Alguém poderia advogar que a memória pode ser "trocada para o disco", mas em algum momento as informações do endereço excederão o tamanho endereçável.

Na prática, essas restrições são irrelevantes para a integridade de Turing. O requisito real é permitir que a fita seja arbitrária por muito tempo, não infinita. Isso criaria um problema de parada de um tipo diferente (como o universo "calcula" a fita?)

É tão falso quanto dizer "Python não é Turing completo porque você não pode fazer uma lista infinitamente grande".

[Edit: obrigado ao Sr. Whitledge por esclarecer como editar.]

A mídia removível nos permite contornar o problema de memória ilimitada. Talvez as pessoas pensem que isso é um abuso, mas acho que está tudo bem e é inevitável, de qualquer maneira.

Corrija qualquer implementação de uma máquina universal de Turing. Para a fita, usamos mídia removível. Quando a cabeça sai do final ou do início do disco atual, a máquina solicita que o usuário insira o próximo ou o anterior. Podemos usar um marcador especial para indicar a extremidade esquerda da fita simulada ou ter uma fita sem limites nas duas direções.

O ponto principal aqui é que tudo o que o programa C deve fazer é finito. O computador precisa apenas de memória suficiente para simular o autômato e size_tprecisa ser grande o suficiente para permitir endereçar essa quantidade (realmente pequena) de memória e dos discos, que podem ter qualquer tamanho finito fixo. Como o usuário é solicitado apenas a inserir o disco seguinte ou anterior, não precisamos de números inteiros ilimitados para dizer "Insira o número do disco 123456 ..."

Suponho que a principal objeção provavelmente seja o envolvimento do usuário, mas isso parece inevitável em qualquer implementação, porque parece não haver outra maneira de implementar a memória ilimitada.

Escolha size_tser infinitamente grande

Você pode optar size_tpor ser infinitamente grande. Naturalmente, é impossível realizar essa implementação. Mas isso não é surpresa, dada a natureza finita do mundo em que vivemos.

Implicações práticas

Mas, mesmo que fosse possível realizar essa implementação, haveria questões práticas. Considere a seguinte instrução C:

printf("%zu\n",SIZE_MAX);

SIZE_MAXSIZE_MAX$O(2^{size\_t})$size_tSIZE_MAXprintf

Felizmente, para nossos propósitos teóricos, não pude encontrar nenhum requisito na especificação que garanta printfque terminará para todas as entradas. Portanto, até onde sei, não violamos a especificação C aqui.

Sobre Completude Computacional

Ainda resta provar que nossa implementação teórica é Turing Complete . Podemos mostrar isso implementando "qualquer máquina de Turing com uma única fita".

A maioria de nós provavelmente implementou uma Máquina de Turing como um projeto escolar. Não vou dar os detalhes de uma implementação específica, mas aqui está uma estratégia comumente usada:

• O número de estados, o número de símbolos e a tabela de transição de estados são fixos para qualquer máquina. Portanto, podemos representar estados e símbolos como números e a tabela de transição de estados como uma matriz bidimensional.
• A fita pode ser representada como uma lista vinculada. Podemos usar uma única lista com vínculo duplo ou duas listas com um vínculo único (uma para cada direção a partir da posição atual).

Agora vamos ver o que é necessário para realizar essa implementação:

• A capacidade de representar um conjunto fixo, mas arbitrariamente grande, de números. Para representar qualquer número arbitrário, também escolhemos MAX_INTser infinitos. (Como alternativa, poderíamos usar outros objetos para representar estados e símbolos.)
• A capacidade de construir uma lista vinculada arbitrariamente grande para nossa fita. Mais uma vez, não há limite finito no tamanho. Isso significa que não podemos construir essa lista antecipadamente, pois gastaríamos uma eternidade apenas para construir nossa fita. Porém, podemos construir essa lista incrementalmente se usarmos a alocação dinâmica de memória. Podemos usar malloc, mas há um pouco mais a considerar:
  • A especificação C permite mallocfalhar se, por exemplo, a memória disponível tiver sido esgotada. Portanto, nossa implementação é verdadeiramente universal, se mallocnunca falhar.
  • No entanto, se nossa implementação for executada em uma máquina com memória infinita, não haverá necessidade de mallocfalha. Sem violar o padrão C, nossa implementação garantirá que mallocnunca falhará.
• A capacidade de remover referências de ponteiros, procurar elementos da matriz e acessar os membros de um nó de lista vinculado.

Portanto, a lista acima é o que é necessário para implementar uma Máquina de Turing em nossa hipotética implementação em C. Esses recursos devem terminar. Qualquer outra coisa, no entanto, pode ter permissão para não terminar (a menos que exigido pela norma). Isso inclui aritmética, E / S, etc.

O argumento principal aqui foi que o tamanho do size_t é finito, embora possa ser infinitamente grande.

Existe uma solução alternativa para isso, embora não tenha certeza se isso coincide com a ISO C.

Suponha que você tenha uma máquina com memória infinita. Portanto, você não está limitado ao tamanho do ponteiro. Você ainda tem seu tamanho size_t. Se você me perguntar o que é sizeof (size_t), a resposta será apenas sizeof (size_t). Se você perguntar se é maior que 100, por exemplo, a resposta é sim. Se você perguntar o que é sizeof (size_t) / 2, como você pode imaginar, a resposta ainda é sizeof (size_t). Se você quiser imprimi-lo, podemos concordar com alguns resultados. A diferença desses dois pode ser NaN e assim por diante.

O resumo é que relaxar a condição para size_t ter tamanho finito não interromperá nenhum programa já existente.

PS Ainda é possível alocar tamanho de memória sizeof (size_t), você só precisa de tamanho contável, então digamos que você faça todos os ajustes (ou truque semelhante).

Sim.

1. Resposta citada

Como reação à grande quantidade de votos negativos nas minhas (e outras) respostas corretas - em comparação com a alarmante aprovação de respostas falsas -, procurei uma explicação alternativa menos teoricamente profunda. Eu encontrei este . Espero que abranja algumas das falácias comuns aqui, para que um pouco mais de insight seja mostrado. Parte essencial do argumento:

[...] Seu argumento é o seguinte: suponha que alguém tenha escrito um determinado programa de término que possa exigir, durante sua execução, até uma quantidade arbitrária de armazenamento. Sem alterar esse programa, é possível a posteriori implementar um hardware de computador e seu compilador C que fornecem armazenamento suficiente para acomodar esse cálculo. Isso pode exigir o alargamento das larguras de caracteres (via CHAR_BITS) e / ou ponteiros (via size_t), mas o programa não precisaria ser modificado. Como isso é possível, C é realmente Turing-Complete para finalizar programas.

A parte complicada desse argumento é que ele só funciona quando se considera o encerramento de programas. Os programas de término têm essa propriedade legal de que eles têm um limite superior estático para seus requisitos de armazenamento, que podem ser determinados experimentalmente executando o programa na entrada desejada, com tamanhos crescentes de armazenamento, até que "caiba".

A razão pela qual eu estava enganado na minha linha de pensamento é que eu estava considerando a classe mais ampla de programas não-úteis "não termináveis" [...]

Em resumo, porque para cada função computável existe uma solução na linguagem C (devido aos limites superiores ilimitados), todo problema computável possui um programa C, portanto C é Turing-completo.

2. Minha resposta original

Existem confusões generalizadas entre conceitos matemáticos na ciência da computação teórica (como a integralidade de Turing) e sua aplicação no mundo real, ou seja, técnicas em ciência da computação prática. A perfeição de Turing não é uma propriedade de máquinas fisicamente existentes ou de qualquer modelo limitado no espaço-tempo. É apenas um objeto abstrato que descreve propriedades de teorias matemáticas.

O C99 é Turing-complete, independentemente das restrições baseadas na implementação, como praticamente qualquer outra linguagem de programação comum, pois é capaz de expressar um conjunto funcionalmente completo de conectivos lógicos e, em princípio, tem acesso a uma quantidade ilimitada de memória. As pessoas apontaram que C restringe explicitamente o acesso à memória aleatória para ser limitado, mas isso não é algo que não possa ser contornado, uma vez que essas são restrições adicionais declaradas no padrão C, enquanto a integridade de Turing é necessária sem elas :

Aqui está uma coisa muito básica sobre sistemas lógicos que deve ser suficiente para uma prova não construtiva . Considere um cálculo com alguns esquemas e regras de axioma, de modo que o conjunto de conseqüências lógicas seja X. Agora, se você adicionar algumas regras ou axiomas, o conjunto de consequências lógicas aumentará, ou seja, deve ser um superconjunto de X. É por isso que, por exemplo, , a lógica modal S4 está adequadamente contida em S5. Da mesma forma, quando você tem uma subespecificação completa de Turing, mas adiciona algumas restrições na parte superior, elas não impedem nenhuma das conseqüências em X, ou seja, deve haver uma maneira de contornar todas as restrições. Se você deseja um idioma não completo de Turing, o cálculo deve ser reduzido, não estendido. Extensões que afirmam que algo não seria possível, mas na verdade são, apenas adicionam inconsistência. Essas inconsistências no padrão C podem não ter conseqüências práticas, assim como a integridade de Turing não está relacionada à aplicação prática.

Simulando números arbitrários baseado em profundidade de recursão (ou seja, este , com a possibilidade de apoiar vários números através de agendamento / pseudo-threads; não há limite teórico para a profundidade de recursão em C ), ou usando o armazenamento de arquivos para simular memória programa ilimitado ( ideia ) são provavelmente apenas duas dentre infinitas possibilidades para provar construtivamente a completude de Turing de C99. É preciso lembrar que, para computabilidade, a complexidade do tempo e do espaço é irrelevante. Em particular, assumir um ambiente limitado para falsificar a completude de Turing é apenas um raciocínio circular, uma vez que essa limitação exclui todos os problemas que excedem o limite de complexidade pressuposto.

( NOTA : Eu apenas escrevi esta resposta para impedir que as pessoas sejam impedidas de obter intuição matemática devido a algum tipo de pensamento limitado orientado a aplicativos. É uma pena que a maioria dos alunos leia a resposta falsa aceita por ser votada com base em falhas fundamentais de raciocínio, para que mais pessoas espalhem essas falsas crenças. Se você rejeitar esta resposta, você será apenas parte do problema.)