Sức mạnh tính toán tối đa của việc thực hiện C

Nếu chúng ta đi theo cuốn sách (hoặc bất kỳ phiên bản nào khác của đặc tả ngôn ngữ nếu bạn thích), thì việc triển khai C có thể có bao nhiêu sức mạnh tính toán?

Lưu ý rằng việc triển khai của C C có một ý nghĩa kỹ thuật: đó là một khởi tạo cụ thể của đặc tả ngôn ngữ lập trình C trong đó hành vi được xác định thực hiện được ghi lại. Việc thực hiện AC không cần phải chạy trên máy tính thực tế. Nó phải thực hiện toàn bộ ngôn ngữ, bao gồm mọi đối tượng có biểu diễn chuỗi bit và các loại có kích thước do xác định thực hiện.

Đối với mục đích của câu hỏi này, không có lưu trữ bên ngoài. Đầu vào / đầu ra duy nhất bạn có thể thực hiện là getchar(để đọc đầu vào chương trình) và putchar(để ghi đầu ra chương trình). Ngoài ra, bất kỳ chương trình nào gọi hành vi không xác định là không hợp lệ: một chương trình hợp lệ phải có hành vi được xác định bởi đặc tả C cộng với mô tả thực hiện các hành vi được xác định thực hiện được liệt kê trong phụ lục J (cho C99). Lưu ý rằng việc gọi các chức năng thư viện không được đề cập trong tiêu chuẩn là hành vi không xác định.

Phản ứng ban đầu của tôi là việc triển khai C không hơn gì một máy tự động hữu hạn, bởi vì nó có giới hạn về dung lượng bộ nhớ địa chỉ (bạn không thể giải quyết nhiều hơn sizeof(char*) * CHAR_BITcác bit lưu trữ, vì các địa chỉ bộ nhớ riêng biệt phải có các mẫu bit riêng biệt khi được lưu trữ trong một con trỏ byte).

Tuy nhiên tôi nghĩ rằng một triển khai có thể làm nhiều hơn thế. Theo như tôi có thể nói, tiêu chuẩn áp đặt không giới hạn về độ sâu của đệ quy. Vì vậy, bạn có thể thực hiện bao nhiêu cuộc gọi hàm đệ quy tùy thích, chỉ tất cả trừ một số lượng cuộc gọi hữu hạn phải sử dụng các registerđối số không thể định địa chỉ ( ). Do đó, việc thực hiện C cho phép đệ quy tùy ý và không có giới hạn về số lượng registerđối tượng có thể mã hóa automata đẩy xuống xác định.

Điều này có đúng không? Bạn có thể tìm thấy một triển khai C mạnh mẽ hơn? Có thực hiện Turing-Complete C không?

Như đã lưu ý trong câu hỏi, tiêu chuẩn C yêu cầu tồn tại một giá trị UCHAR_MAX sao cho mọi biến loại unsigned charsẽ luôn giữ một giá trị trong khoảng từ 0 đến UCHAR_MAX. Nó đòi hỏi thêm rằng mọi đối tượng được phân bổ động phải được biểu diễn bằng một chuỗi byte có thể nhận dạng thông qua con trỏ loại unsigned char*và có một hằng số sizeof(unsigned char*)sao cho mọi con trỏ của loại đó có thể được xác định bởi một chuỗi các sizeof(unsigned char *)giá trị loại unsigned char. Do đó, số lượng đối tượng có thể được phân bổ động đồng thời bị giới hạn cứng đối với 10 10 đối tượng, nhưng từ góc độ lý thuyết, sự tồn tại của bất kỳ ràng buộc nào, dù lớn đến đâu, có nghĩa là một cái gì đó không phải là vô hạn. . Không có gì ngăn cản trình biên dịch lý thuyết gán các giá trị của các hằng số đó để hỗ trợ hơn$UCHAR\_MAX ^{sizeof(unsigned\ char*)}$$10^{10^{10}}$

Một chương trình có thể lưu trữ một lượng thông tin không giới hạn trên ngăn xếp nếu không có gì được phân bổ trên ngăn xếp bao giờ có địa chỉ của nó ; do đó, người ta có thể có một chương trình C có khả năng thực hiện một số điều mà không thể thực hiện được bởi bất kỳ máy tự động hữu hạn nào ở bất kỳ kích thước nào. Do đó, mặc dù (hoặc có lẽ vì) quyền truy cập vào các biến ngăn xếp bị hạn chế hơn nhiều so với quyền truy cập vào các biến được phân bổ động, nhưng nó biến C từ một máy tự động hữu hạn thành máy tự động đẩy xuống.

Tuy nhiên, có một nếp nhăn tiềm năng khác: yêu cầu rằng nếu một chương trình kiểm tra các chuỗi có độ dài cố định cơ bản của các giá trị ký tự được liên kết với hai con trỏ tới các đối tượng khác nhau, thì các chuỗi đó phải là duy nhất. Bởi vì chỉ có $UCHAR\_MAX ^{sizeof(unsigned\ char*)}$các chuỗi có thể có của các giá trị ký tự, bất kỳ chương trình nào tạo ra một số con trỏ tới các đối tượng riêng biệt vượt quá mức đó không thể tuân thủ tiêu chuẩn C rất chậm], sau đó thực sự có thể biến C thành ngôn ngữ hoàn chỉnh.nếu mã đã từng kiểm tra chuỗi ký tự được liên kết với các con trỏ đó . Tuy nhiên, trong một số trường hợp, trình biên dịch có thể xác định rằng không có mã nào sẽ kiểm tra chuỗi ký tự được liên kết với một con trỏ. Nếu mỗi "char" thực sự có khả năng chứa bất kỳ số nguyên hữu hạn nào và bộ nhớ của máy là một chuỗi số nguyên vô hạn [được cung cấp một máy Turing băng không giới hạn, thì người ta có thể mô phỏng một máy như vậy mặc dù nó sẽ là

Với thư viện phân luồng (tùy chọn) của C11, có thể thực hiện triển khai Turing hoàn chỉnh với độ sâu đệ quy không giới hạn.

Tạo một chủ đề mới mang lại một ngăn xếp thứ hai; hai ngăn xếp là đủ cho Turing hoàn chỉnh. Một ngăn xếp đại diện cho những gì ở bên trái của đầu, ngăn xếp khác những gì ở bên phải.

Tôi nghĩ rằng nó đã hoàn thành : chúng ta có thể viết chương trình mô phỏng UTM bằng thủ thuật này (tôi đã nhanh chóng viết mã bằng tay để có thể có một số lỗi cú pháp ... nhưng tôi hy vọng không có lỗi (chính) nào trong logic :-)

• định nghĩa một cấu trúc có thể được sử dụng như một danh sách liên kết kép để biểu diễn băng

    typdef struct {
      cell_t * trước; // ô bên trái
      cell_t * succ; // ô bên phải
      int val; // giá trị ô
    } cell_t 

Nó headsẽ là một con trỏ tới một cell_tcấu trúc

• xác định cấu trúc có thể được sử dụng để lưu trữ trạng thái hiện tại và cờ

    typedef struct {
      int nhà nước;
      cờ int;
    } thông tin 

• sau đó xác định hàm vòng lặp đơn mô phỏng Universal TM khi phần đầu nằm giữa ranh giới của danh sách liên kết kép; khi đầu chạm vào một ranh giới, đặt cờ của cấu trúc info_t (HIT_LEFT, HIT_RIGHT) và trả về:

void simulation_UTM (cell_t * head, info_t * information) {
  trong khi (đúng) {
    head-> val = UTM_nextsymbol [thông tin-> trạng thái, head-> val]; // viết ký hiệu
    thông tin-> bang = UTM_nextstate [thông tin-> trạng thái, đầu-> val]; // trạng thái tiếp theo
    if (thông tin-> state == HALT_STATE) {// in nếu chấp nhận và thoát khỏi chương trình
       putchar ((thông tin-> bang == ACCEPT_STATE)? '1': '0');
       thoát (0);
    }
    int move = UTM_nextmove [thông tin-> trạng thái, đầu-> val];
    if (di chuyển == MOVE_LEFT) {
      đầu = đầu-> trước; // di chuyển sang trái
      if (head == NULL) {thông tin-> cờ = HIT_LEFT; trở về; }
    } khác {
      đầu = đầu-> succ; // đi sang phải
      if (head == NULL) {thông tin-> cờ = HIT_RIGHT; trở về; }
    }
  } // vẫn còn trong ranh giới ... tiếp tục
}

• sau đó xác định hàm đệ quy trước tiên gọi thủ tục UTM mô phỏng và sau đó gọi đệ quy chính nó khi băng cần được mở rộng; khi băng cần được mở rộng ở trên cùng (HIT_RIGHT) không có vấn đề gì, khi băng cần được dịch ở phía dưới (HIT_LEFT) chỉ cần dịch chuyển các giá trị của các ô bằng danh sách được liên kết kép:

void stacker (cell_t * top, cell_t * bottom, cell_t * head, info_t * information) {
  mô phỏng_UTM (đầu, thông tin);
  cell_t newcell; // ô mới
  newcell.pred = top; // cập nhật danh sách liên kết kép với ô mới
  newcell.succ = NULL;
  đầu trang-> succ = & newcell;
  newcell.val = EMPTY_SYMBOL;

  chuyển đổi (thông tin-> nhấn) {
    trường hợp HIT_RIGHT:
      stacker (& newcell, bottom, newcell, thông tin);
      phá vỡ;
    trường hợp HIT_BOTTOM:
      cell_t * tmp = newcell;
      while (tmp-> pre! = NULL) {// thay đổi giá trị
        tmp-> val = tmp-> pre-> val;
        tmp = tmp-> trước;
      }
      tmp-> val = EMPTY_SYMBOL;
      stacker (& newcell, đáy, đáy, thông tin);
      phá vỡ;
  }
}

• băng ban đầu có thể được lấp đầy bằng một hàm đệ quy đơn giản, xây dựng danh sách liên kết đôi và sau đó gọi stackerhàm khi nó đọc ký hiệu cuối cùng của băng đầu vào (sử dụng hàm đọc)

void init_tape (cell_t * top, cell_t * bottom, info_t * thông tin) {
  cell_t newcell;
  int c = readar ();
  ngăn xếp if (c == END_OF_INPUT) (& top, bottom, bottom, information); // không còn ký hiệu, bắt đầu
  newcell.pred = top;
  if (top! = NULL) top.succ = & newcell; đáy khác = & newcell;
  init_tape (& newcell, dưới cùng, thông tin);
}

EDIT: sau khi suy nghĩ một chút về nó, có một vấn đề với con trỏ ...

nếu mọi cuộc gọi của hàm đệ quy stackercó thể tạo ra một con trỏ hợp lệ cho một biến được định nghĩa cục bộ trong trình gọi thì mọi thứ đều ổn ; mặt khác, thuật toán của tôi không thể xác định danh sách liên kết đôi hợp lệ trên đệ quy không giới hạn (và trong trường hợp này, không thấy cách sử dụng đệ quy để mô phỏng bộ lưu trữ truy cập ngẫu nhiên không giới hạn).

Miễn là bạn có kích thước ngăn xếp cuộc gọi không giới hạn, bạn có thể mã hóa băng của mình trên ngăn xếp cuộc gọi và truy cập ngẫu nhiên bằng cách tua lại con trỏ ngăn xếp mà không quay lại từ các lệnh gọi hàm.

EdIT : Nếu bạn chỉ có thể sử dụng ram, là hữu hạn, công trình này không hoạt động nữa, vì vậy hãy xem bên dưới.

Tuy nhiên, rất có vấn đề tại sao ngăn xếp của bạn có thể là vô hạn nhưng ram nội tại thì không. Vì vậy, thực sự tôi sẽ nói rằng bạn thậm chí không thể nhận ra tất cả các ngôn ngữ thông thường, vì số lượng trạng thái bị giới hạn (nếu bạn không tính thủ thuật tua lại ngăn xếp để khai thác ngăn xếp vô hạn).

Tôi thậm chí sẽ suy đoán rằng số lượng ngôn ngữ bạn có thể nhận ra là hữu hạn (ngay cả khi bản thân các ngôn ngữ có thể là vô hạn, ví dụ như a*không sao, nhưng b^kchỉ hoạt động với số lượng hữu hạn k).

EDIT : Điều này không đúng, vì bạn có thể mã hóa trạng thái hiện tại trong các chức năng bổ sung, vì vậy bạn có thể thực sự nhận ra TẤT CẢ các ngôn ngữ thông thường.

Rất có thể bạn có thể nhận được tất cả các ngôn ngữ Loại 2 vì cùng một lý do, nhưng tôi không chắc liệu bạn có thể quản lý để đặt cả hai, trạng thái không và ngăn xếp ngăn xếp vào ngăn xếp cuộc gọi hay không. Nhưng trên một lưu ý chung, bạn có thể quên ram một cách hiệu quả, vì bạn luôn có thể chia tỷ lệ kích thước của máy tự động để bảng chữ cái của bạn vượt quá khả năng của ram. Vì vậy, nếu bạn có thể mô phỏng một TM chỉ với một ngăn xếp, Loại 2 sẽ bằng Loại 0, phải không?

Tôi đã nghĩ về điều này một lần và quyết định thử thực hiện một ngôn ngữ phi ngữ cảnh bằng cách sử dụng ngữ nghĩa dự kiến; phần quan trọng của việc thực hiện là chức năng sau:

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

Ít nhất, tôi nghĩ rằng điều này làm việc. Có thể là tôi đang mắc một số sai lầm cơ bản.

Một phiên bản cố định:

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

Dọc theo dòng câu trả lời của @ supercat:

Các tuyên bố về tính không hoàn chỉnh của C dường như tập trung vào các đối tượng riêng biệt đó nên có các địa chỉ riêng biệt và tập hợp các địa chỉ được coi là hữu hạn. Như @supercat viết

Như đã lưu ý trong câu hỏi, tiêu chuẩn C yêu cầu tồn tại một giá trị UCHAR_MAXsao cho mọi biến kiểu char không dấu sẽ luôn giữ một giá trị trong khoảng từ 0 đến UCHAR_MAX, bao gồm. Nó đòi hỏi thêm rằng mọi đối tượng được phân bổ động phải được biểu diễn bằng một chuỗi byte có thể nhận dạng được thông qua con trỏ của kiểu không dấu char * và có một hằng số sizeof(unsigned char*)sao cho mọi con trỏ của loại đó được nhận dạng bởi một chuỗisizeof(unsigned char *) giá trị loại không dấu char

Tôi tự hỏi nếu C cho phép chúng ta vận hành các chuỗi và chuỗi byte vô hạn. Nếu vậy, chúng ta có thể lấy tập hợp unsigned char*con trỏ là$\mathbb{N}$ và tập hợp các ký tự không dấu $\{0, 1\}$chỉ để đơn giản. Sau đó, chúng ta nên xác định sizeof(unsigned char*), st cardinality bộ$\{0, 1\}^{\operatorname{sizeof}(\mathit{unsigned\ char*})}$ không ít hơn cardinality của $\mathbb{N}$. Bằng cách này, với mọi con trỏ, chúng ta có thể gán một chuỗi các ký tự không dấu có độ dài phù hợp. Điều này hoạt động nếu được xác định sizeof(unsigned char*)là$\mathbb{N}$ ($\omega$ nếu bạn ước).

Tại thời điểm này, người ta nên kiểm tra rằng tiêu chuẩn C thực sự sẽ cho phép điều đó.

Một vấn đề nhỏ trong việc xây dựng này là không phải mọi chuỗi ký tự không dấu đều biểu thị một con trỏ. Điều này có thể hoặc có thể không tốt, nhưng có thể được sửa chữa nếu cần. Nhưng cũng có thể là tiêu chuẩn sẽ "vô tình" yêu cầu các biểu diễn byte của các đối tượng là hữu hạn hoặc một số số là số nguyên (giả sử, kết quả sizeofluôn luôn là$\in \mathbb Z$) và sau đó chúng ta có thể hết may mắn.