Максимальна обчислювальна потужність реалізації С

Якщо ми підемо за книгою (або будь-якою іншою версією специфікації мови, якщо вам зручніше), яку обчислювальну потужність може мати реалізація C?

Зауважте, що "реалізація C" має технічне значення: це особливе опис специфікації мови програмування C, де документально визначена поведінка. Реалізація змінного струму не повинна працювати на фактичному комп’ютері. Він повинен реалізувати всю мову, включаючи кожен об'єкт, що має представлення бітових рядків і типи, що мають розмір, визначений реалізацією.

Для цього питання немає зовнішнього сховища. Єдиний вхід / вихід, який ви можете виконати, - це getchar(для читання введення програми) та putchar(для запису програмного результату). Також недійсна будь-яка програма, яка викликає невизначене поведінку: дійсна програма повинна мати свою поведінку, визначену специфікацією C плюс опис реалізації поведінки, визначеної в додатку J (для C99). Зауважте, що виклики функцій бібліотеки, які не згадуються у стандарті, є невизначеною поведінкою.

Моя початкова реакція полягала в тому, що реалізація C - це не що інше, як обмежений автомат, оскільки він має обмеження на кількість адресируемой пам'яті (ви не можете адресувати більше sizeof(char*) * CHAR_BITбітів пам’яті, оскільки окремі адреси пам'яті повинні мати чіткі бітові шаблони при зберіганні у байтовому покажчику).

Однак я думаю, що реалізація може зробити більше, ніж це. Наскільки я можу сказати, стандарт не встановлює обмежень на глибину рекурсії. Таким чином, ви можете робити стільки рекурсивних викликів функцій, скільки вам потрібно, лише всі, окрім обмеженої кількості дзвінків, повинні використовувати registerаргументи, що не адресовані ( ). Таким чином, реалізація C, яка дозволяє довільну рекурсію і не обмежує кількість registerоб'єктів, може кодувати детерміновані автоматичні витиски.

Це правильно? Чи можете ви знайти більш потужну реалізацію C? Чи існує реалізація системи Turing?

unsigned charunsigned char*sizeof(unsigned char*)sizeof(unsigned char *)unsigned char$UCHAR\_MAX ^{sizeof(unsigned\ char*)}$$10^{10^{10}}$

Програма може зберігати необмежену кількість інформації в стеку, якщо ніщо, що виділяється на стек, ніколи не приймає свою адресу ; Таким чином, можна було б мати програму С, здатну робити деякі речі, які не можна було зробити жодним обмеженим автоматом будь-якого розміру. Таким чином, навіть якщо (або, можливо, тому, що) доступ до змінних стеків значно обмежений, ніж доступ до динамічно розподілених змінних, це перетворює C з кінцевого автомата в автоматичний поштовх.

$UCHAR\_MAX ^{sizeof(unsigned\ char*)}$можливі послідовності знаків символів; будь-яка програма, яка створила ряд покажчиків на виділення об'єктів, що перевищують це, не могла відповідати стандарту C, якщо код коли-небудь перевіряв послідовність символів, пов'язаних з цими вказівниками . Однак у деяких випадках компілятор міг би визначити, що жоден код ніколи не збирається досліджувати послідовність символів, пов'язаних з покажчиком. Якщо кожен «char» насправді міг би містити будь-яке кінцеве ціле число, а пам’ять машини являла собою незліченно безмежну послідовність цілих чисел [з огляду на необмежену стрічкову машину Тюрінга, можна було б імітувати таку машину, хоча це було б дуже повільно], тоді дійсно можна було б зробити мову цілковою Тюрінгом.

За допомогою бібліотеки різьблення C11 (необов'язково) можна здійснити повну реалізацію Тьюрінга з необмеженою глибиною рекурсії.

Створення нової нитки дає другий стек; Для повноти Тьюрінга достатньо двох стеків. Один стек являє собою те, що знаходиться зліва від голови, інший стопку, що праворуч.

Я думаю, що це Тьюрінг завершений : ми можемо написати програму, яка імітує UTM за допомогою цього фокусу (я швидко написав код вручну, тому, ймовірно, є деякі синтаксичні помилки ... але я сподіваюся, що в логіці немає (основних) помилок :-)

• визначте структуру, яку можна використовувати як подвійний зв'язаний список для подання стрічки

    typdef structure {
      cell_t * pred; // комірка зліва
      cell_t * succ; // комірка праворуч
      int val; // значення комірки
    } cell_t 

headБуде покажчик на cell_tструктуру

• визначте структуру, яку можна використовувати для зберігання поточного стану та прапора

    typedef structure {
      стан стану;
      int прапор;
    } info_t 

• потім визначте функцію єдиного циклу, яка імітує Універсальну ТМ, коли головка знаходиться між межами подвійного пов'язаного списку; коли голова потрапила на межу, встановіть прапор структури info_t (HIT_LEFT, HIT_RIGHT) і поверніть:

void simulate_UTM (cell_t * head, info_t * info) {
  в той час як (правда) {
    head-> val = UTM_nextsymbol [info-> стан, head-> val]; // символ написання
    info-> state = UTM_nextstate [info-> стан, голова-> val]; // наступний стан
    if (info-> state == HALT_STATE) {// print якщо приймає та виходить із програми
       putchar ((info-> state == ACCEPT_STATE)? '1': '0');
       вихід (0);
    }
    int move = UTM_nextmove [info-> стан, голова-> val];
    if (переміщення == MOVE_LEFT) {
      голова = голова-> перед; // рухатися ліворуч
      if (head == NULL) {info-> flag = HIT_LEFT; повернення; }
    } else {
      голова = голова-> сукк; // рухатися праворуч
      if (head == NULL) {info-> flag = HIT_RIGHT; повернення; }
    }
  } // все ще в межі ... йти далі
}

• потім визначте рекурсивну функцію, яка спочатку викликає процедуру моделювання UTM, а потім рекурсивно викликає себе, коли стрічку потрібно розширити; коли стрічку потрібно розгорнути вгорі (HIT_RIGHT) немає проблем, коли її потрібно змістити на низ (HIT_LEFT), просто змістіть значення комірок за допомогою подвійного пов'язаного списку:

недійсний укладальник (cell_t * верх, cell_t * знизу, cell_t * head, info_t * info) {
  simulate_UTM (голова, інформація);
  cell_t newcell; // нова комірка
  newcell.pred = верх; // оновити подвійний зв'язаний список новою коміркою
  newcell.succ = NULL;
  top-> succ = & newcell;
  newcell.val = EMPTY_SYMBOL;

  перемикач (інформація-> хіт) {
    корпус HIT_RIGHT:
      укладальник (& newcell, bottom, newcell, info);
      перерву;
    корпус HIT_BOTTOM:
      cell_t * tmp = newcell;
      while (tmp-> pred! = NULL) {// значення зрушення вгору
        tmp-> val = tmp-> pred-> val;
        tmp = tmp-> pred;
      }
      tmp-> val = EMPTY_SYMBOL;
      укладальник (& newcell, bottom, bottom, info);
      перерву;
  }
}

• початкова стрічка може бути заповнена простою рекурсивною функцією, яка створює подвійний зв'язаний список, а потім викликає stackerфункцію, коли вона читає останній символ вхідної стрічки (використовуючи readchar)

недійсна init_tape (cell_t * верх, cell_t * знизу, info_t * info) {
  cell_t newcell;
  int c = readchar ();
  if (c == END_OF_INPUT) укладальник (& top, bottom, bottom, info); // більше немає символів, почати
  newcell.pred = верх;
  if (top! = NULL) top.succ = & newcell; else bottom = & newcell;
  init_tape (& newcell, bottom, info);
}

EDIT: трохи подумавши про це, виникає проблема з покажчиками ...

якщо кожен виклик рекурсивної функції stackerможе підтримувати дійсний вказівник на змінну, визначену локально у виклику, то все добре ; інакше мій алгоритм не може підтримувати дійсний подвійний зв'язаний список необмеженої рекурсії (і в цьому випадку не бачити способу використання рекурсії для імітації необмеженого сховища з випадковим доступом).

Поки у вас є необмежений розмір стека викликів, ви можете кодувати стрічку на стеку викликів і випадково отримувати доступ до неї, перемотаючи покажчик стека, не повертаючись з функції викликів.

Редагувати : Якщо ви можете використовувати лише таран, який є кінцевим, ця конструкція більше не працює, тому дивіться нижче.

Однак дуже сумнівно, чому ваш стек може бути нескінченним, але суттєвий баран - це не так. Тому насправді я б сказав, що ви навіть не можете розпізнати всі регулярні мови, оскільки кількість штатів обмежена (якщо ви не рахуєте трюк стека-перемотування назад для використання нескінченного стека).

Я б навіть припускав, що кількість мов, які ви можете розпізнати, є кінцевою (навіть якщо самі мови можуть бути нескінченними, наприклад, a*це нормально, але b^kпрацює лише для обмеженої кількості ks).

EDIT : Це неправда, оскільки ви можете кодувати поточний стан додатковими функціями, щоб ви могли справді розпізнати ВСІ звичайні мови.

Ви, швидше за все, можете отримати всі мови типу 2 з тієї ж причини, але я не впевнений, чи зможете ви поставити як стек викликів, так і стан та стек. Але загалом, ви можете ефективно забути про таран, оскільки ви завжди можете масштабувати розмір автомата, щоб ваш алфавіт перевищував ємність барана. Отже, якби ви могли імітувати TM лише стеком, Type-2 дорівнював би типу 0, чи не так?

Я подумав про це один раз і вирішив спробувати впровадити безконтекстну мову, використовуючи очікувану семантику; Ключовою частиною реалізації є наступна функція:

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\}$

Принаймні, я думаю, що це працює. Можливо, я роблю якусь принципову помилку.

Виправлена ​​версія:

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();
}

Відповідно до відповіді @ supercat:

Ствердження про незавершеність C, здається, зосереджені навколо того, що окремі об'єкти повинні мати чіткі адреси, а набір адрес вважається кінцевим. Як пише @supercat

Як зазначається у запитанні, стандарт C вимагає, щоб існувало таке значення UCHAR_MAX, що кожна змінна типу без підпису char завжди матиме значення між 0 і UCHAR_MAXвключно. Він також вимагає, щоб кожен динамічно виділений об'єкт був представлений послідовністю байтів, яку можна ідентифікувати за допомогою вказівника типу непідписаний char *, і щоб була константа sizeof(unsigned char*)такою, щоб кожен вказівник цього типу був ідентифікований послідовністю sizeof(unsigned char *)значень типу без підпису char.

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

На цьому етапі слід перевірити, чи стандарт C справді дозволяє це.

sizeof$\in \mathbb Z$