Máxima potencia computacional de una implementación en C

Si seguimos el libro (o cualquier otra versión de la especificación del lenguaje si lo prefiere), ¿cuánta potencia computacional puede tener una implementación de C?

Tenga en cuenta que "implementación C" tiene un significado técnico: es una instanciación particular de la especificación del lenguaje de programación C donde se documenta el comportamiento definido por la implementación. La implementación de CA no tiene que poder ejecutarse en una computadora real. Tiene que implementar todo el lenguaje, incluidos todos los objetos que tienen una representación de cadena de bits y los tipos que tienen un tamaño definido por la implementación.

A los efectos de esta pregunta, no hay almacenamiento externo. La única entrada / salida que puede realizar es getchar(para leer la entrada del programa) y putchar(para escribir la salida del programa). Además, cualquier programa que invoque un comportamiento indefinido no es válido: un programa válido debe tener su comportamiento definido por la especificación C más la descripción de la implementación de los comportamientos definidos por la implementación enumerados en el apéndice J (para C99). Tenga en cuenta que llamar a funciones de biblioteca que no se mencionan en el estándar es un comportamiento indefinido.

Mi reacción inicial fue que una implementación en C no es más que un autómata finito, ya que tiene un límite en la cantidad de memoria direccionable (no se puede direccionar más que sizeof(char*) * CHAR_BITbits de almacenamiento, ya que distintas direcciones de memoria deben tener patrones de bits distintos cuando se almacenan en un puntero de byte).

Sin embargo, creo que una implementación puede hacer más que esto. Por lo que puedo decir, el estándar no impone ningún límite en la profundidad de la recursión. Por lo tanto, puede realizar tantas llamadas a funciones recursivas como desee, solo todas menos un número finito de llamadas deben usar registerargumentos no direccionables ( ). Por lo tanto, una implementación en C que permite la recursión arbitraria y no tiene límite en el número de registerobjetos puede codificar autómatas de pushdown determinista.

¿Es esto correcto? ¿Puedes encontrar una implementación de C más potente? ¿Existe una implementación de Turing-complete C?

Como se señaló en la pregunta, el estándar C requiere que exista un valor UCHAR_MAX de modo que cada variable de tipo unsigned charsiempre tenga un valor entre 0 y UCHAR_MAX, inclusive. Además, requiere que cada objeto asignado dinámicamente esté representado por una secuencia de bytes que sea identificable mediante un puntero de tipo unsigned char*, y que exista una constante sizeof(unsigned char*)tal que cada puntero de ese tipo sea identificable por una secuencia de sizeof(unsigned char *)valores de tipo unsigned char. El número de objetos que pueden asignarse dinámicamente simultáneamente está, por lo tanto, rígidamente limitado a . Nada impediría que un compilador teórico asigne los valores de esas constantes para soportar más de 10 10 10 objetos, pero desde una perspectiva teórica la existencia de cualquier límite, no importa cuán grande sea, significa que algo no es infinito.$UCHAR\_MAX ^{sizeof(unsigned\ char*)}$$10^{10^{10}}$

Un programa podría almacenar una cantidad ilimitada de información en la pila si nada de lo que se asigna en la pila tiene su dirección tomada ; por lo tanto, se podría tener un programa en C que fuera capaz de hacer algunas cosas que ningún autómata finito de ningún tamaño podría hacer. Por lo tanto, aunque (o tal vez porque) el acceso a las variables de la pila es mucho más limitado que el acceso a las variables asignadas dinámicamente, convierte a C de ser un autómata finito en un autómata pushdown.

Sin embargo, existe otra posible arruga: se requiere que si un programa examina las secuencias subyacentes de longitud fija de valores de caracteres asociados con dos punteros a diferentes objetos, esas secuencias deben ser únicas. Porque solo hay $UCHAR\_MAX ^{sizeof(unsigned\ char*)}$posibles secuencias de valores de caracteres, cualquier programa que creara una cantidad de punteros a objetos distintos que no pudieran cumplir con el estándar C si el código alguna vez examinara la secuencia de caracteres asociados con esos punteros . Sin embargo, en algunos casos sería posible que un compilador determinara que ningún código examinaría la secuencia de caracteres asociada a un puntero. Si cada "char" era realmente capaz de contener cualquier número entero finito, y la memoria de la máquina era una secuencia infinita de números enteros [dada una máquina Turing de cinta ilimitada, uno podría emular una máquina de este tipo aunque sería realmente lenta], entonces de hecho, sería posible hacer de C un lenguaje completo de Turing.

Con la biblioteca de subprocesos de C11 (opcional), es posible realizar una implementación completa de Turing con una profundidad de recursión ilimitada.

Crear un nuevo hilo produce una segunda pila; dos pilas son suficientes para completar Turing. Una pila representa lo que está a la izquierda de la cabeza, la otra pila lo que está a la derecha.

Creo que está completando Turing : podemos escribir un programa que simule un UTM usando este truco (escribí rápidamente el código a mano, por lo que probablemente haya algunos errores de sintaxis ... pero espero que no haya errores (mayores) en la lógica :-)

• Definir una estructura que se pueda utilizar como una lista de doble enlace para la representación en cinta

    typdef struct {
      cell_t * pred; // celda a la izquierda
      cell_t * succ; // celda a la derecha
      int val; // valor de celda
    } cell_t 

El headserá un puntero a una cell_testructura

• definir una estructura que se pueda usar para almacenar el estado actual y una bandera

    typedef struct {
      int estado;
      bandera int;
    } info_t 

• luego defina una función de bucle único que simule un TM universal cuando el encabezado esté entre los límites de la lista de doble enlace; cuando la cabeza alcanza un límite, establece la bandera de la estructura info_t (HIT_LEFT, HIT_RIGHT) y regresa:

void simulate_UTM (cell_t * head, info_t * info) {
  while (verdadero) {
    head-> val = UTM_nextsymbol [info-> state, head-> val]; // escribir símbolo
    info-> state = UTM_nextstate [info-> state, head-> val]; // siguiente estado
    if (info-> state == HALT_STATE) {// print if acepta y sale del programa
       putchar ((info-> state == ACCEPT_STATE)? '1': '0');
       salida (0);
    }
    int move = UTM_nextmove [info-> estado, head-> val];
    if (mover == MOVE_LEFT) {
      cabeza = cabeza-> pred; // mover hacia la izquierda
      if (head == NULL) {info-> flag = HIT_LEFT; regreso; }
    } más {
      cabeza = cabeza-> succ; // moverse a la derecha
      if (head == NULL) {info-> flag = HIT_RIGHT; regreso; }
    }
  } // todavía en el límite ... continúa
}

• luego defina una función recursiva que primero llama a la rutina UTM de simulación y luego se llama recursivamente a sí misma cuando la cinta necesita expandirse; cuando la cinta necesita expandirse en la parte superior (HIT_RIGHT) sin problemas, cuando necesita desplazarse en la parte inferior (HIT_LEFT) simplemente cambie los valores de las celdas usando la lista de doble enlace:

apilador vacío (cell_t * top, cell_t * bottom, cell_t * head, info_t * info) {
  simulate_UTM (head, info);
  cell_t newcell; // la nueva celda
  newcell.pred = top; // actualiza la lista de doble enlace con la nueva celda
  newcell.succ = NULL;
  top-> succ = & newcell;
  newcell.val = EMPTY_SYMBOL;

  interruptor (información-> golpear) {
    caso HIT_RIGHT:
      apilador (& newcell, bottom, newcell, info);
      descanso;
    caso HIT_BOTTOM:
      cell_t * tmp = newcell;
      while (tmp-> pred! = NULL) {// valores ascendentes
        tmp-> val = tmp-> pred-> val;
        tmp = tmp-> pred;
      }
      tmp-> val = EMPTY_SYMBOL;
      apilador (& newcell, fondo, fondo, información);
      descanso;
  }
}

• la cinta inicial se puede llenar con una función recursiva simple que construye la lista de doble enlace y luego llama a la stackerfunción cuando lee el último símbolo de la cinta de entrada (usando readchar)

vacío init_tape (cell_t * top, cell_t * bottom, info_t * info) {
  cell_t newcell;
  int c = readchar ();
  if (c == END_OF_INPUT) apilador (& arriba, abajo, abajo, información); // no más símbolos, comenzar
  newcell.pred = top;
  if (top! = NULL) top.succ = & newcell; de lo contrario bottom = & newcell;
  init_tape (& newcell, bottom, info);
}

EDITAR: después de pensar un poco al respecto, hay un problema con los punteros ...

si cada llamada de la función recursiva stackerpuede mantener un puntero válido a una variable definida localmente en la persona que llama, entonces todo está bien ; de lo contrario, mi algoritmo no puede mantener una lista válida de doble enlace en la recursión ilimitada (y en este caso no veo una manera de usar la recursión para simular un almacenamiento ilimitado de acceso aleatorio).

Siempre que tenga un tamaño ilimitado de la pila de llamadas, puede codificar su cinta en la pila de llamadas y acceder aleatoriamente rebobinando el puntero de la pila sin regresar de las llamadas a funciones.

Edición : si solo puede usar el carnero, que es finito, esta construcción ya no funciona, así que vea a continuación.

Sin embargo, es muy cuestionable por qué su pila puede ser infinita pero el ariete intrínseco no. Entonces, en realidad, diría que ni siquiera puede reconocer todos los idiomas regulares, ya que el número de estados está limitado (si no cuenta el truco de pila-rebobinado para explotar la pila infinita).

Incluso podría especular que el número de idiomas que puede reconocer es finito (incluso si los idiomas mismos pueden ser infinitos, por ejemplo, a*está bien, pero b^ksolo funciona para un número finito de ks).

EDITAR : Esto no es cierto, ya que puede codificar el estado actual en funciones adicionales, por lo que realmente puede reconocer TODOS los idiomas regulares.

Lo más probable es que pueda obtener todos los idiomas de Tipo 2 por la misma razón, pero no estoy seguro de si puede colocar ambos, el estado y el contenido de la pila en la pila de llamadas. Pero en términos generales, puede olvidarse efectivamente del carnero, ya que siempre puede escalar el tamaño del autómata para que su alfabeto exceda la capacidad del carnero. Entonces, si pudieras simular una TM con solo una pila, Tipo-2 sería igual a Tipo-0, ¿no?

Pensé en esto una vez y decidí intentar implementar un lenguaje sin contexto utilizando la semántica esperada; La parte clave de la implementación es la siguiente función:

void *it;

void read_triple(void *back)
{
  if(read_a()) read_triple(&back);
  else reject();
  for(it = back; it != NULL; it = *it)
     if(!read_b()) reject();
  if(read_c()) return;
  else reject();
}

$\{a^n b^n c^n\}$

Al menos, creo que esto funciona. Sin embargo, puede ser que esté cometiendo un error fundamental.

Una versión fija:

void *it;

void read_triple(void *back)
{
  if(read_a()) read_triple(&back);
  else for(it = back; it != NULL; it = * (void **) it)
     if(!read_b()) reject();
  if(read_c()) return;
  else reject();
}

En la línea de la respuesta de @ supercat:

Las afirmaciones de incompletitud de C parecen centrarse en que los objetos distintos deben tener direcciones distintas, y se supone que el conjunto de direcciones es finito. Como escribe @supercat

Como se señaló en la pregunta, el estándar C requiere que exista un valor UCHAR_MAXtal que cada variable de tipo unsigned char siempre tendrá un valor entre 0 e UCHAR_MAX, inclusive. Además, requiere que cada objeto asignado dinámicamente esté representado por una secuencia de bytes que sea identificable mediante un puntero de tipo unsigned char *, y que exista una constante sizeof(unsigned char*)tal que cada puntero de ese tipo sea identificable por una secuencia de sizeof(unsigned char *)valores de tipo unsigned carbonizarse.

unsigned char*$\mathbb{N}$$\{0, 1\}$sizeof(unsigned char*)$\{0, 1\}^{\operatorname{sizeof}(\mathit{unsigned\ char*})}$$\mathbb{N}$sizeof(unsigned char*)$\mathbb{N}$$\omega$

En este punto, uno debería verificar que el estándar C lo permitiría.

sizeof$\in \mathbb Z$