Tôi đã cố gắng giải thích với ai đó rằng C là Turing-Complete và nhận ra rằng tôi thực sự không biết liệu đó có thực sự là Turing hoàn chỉnh hay không. (C như trong ngữ nghĩa trừu tượng, không phải như trong một triển khai thực tế.)

Câu trả lời "rõ ràng" (đại khái: nó có thể giải quyết một lượng bộ nhớ tùy ý, do đó, nó có thể mô phỏng một máy RAM, do đó, Turing-perfect) thực sự không chính xác, theo như tôi có thể nói, mặc dù tiêu chuẩn C cho phép để size_t lớn tùy ý, nó phải được cố định ở một độ dài nào đó và cho dù nó có cố định ở độ dài nào thì nó vẫn hữu hạn. (Nói cách khác, mặc dù bạn có thể, được cung cấp một máy Turing tạm dừng tùy ý, chọn độ dài size_t để nó chạy "đúng", không có cách nào để chọn độ dài size_t sao cho tất cả các máy Turing tạm dừng sẽ chạy đúng)

Vậy: C99 Turing đã hoàn thành chưa?

Tôi không chắc nhưng tôi nghĩ câu trả lời là không, vì những lý do khá tinh tế. Tôi đã hỏi về Khoa học máy tính lý thuyết một vài năm trước và không nhận được câu trả lời nào vượt xa những gì tôi sẽ trình bày ở đây.

Trong hầu hết các ngôn ngữ lập trình, bạn có thể mô phỏng máy Turing bằng cách:

• mô phỏng máy tự động hữu hạn với chương trình sử dụng một lượng bộ nhớ hữu hạn;
• mô phỏng băng với một cặp danh sách các số nguyên được liên kết, thể hiện nội dung của băng trước và sau vị trí hiện tại. Di chuyển con trỏ có nghĩa là chuyển đầu của một trong các danh sách sang danh sách khác.

Một triển khai cụ thể chạy trên máy tính sẽ hết bộ nhớ nếu băng quá dài, nhưng một triển khai lý tưởng có thể thực hiện chương trình máy Turing một cách trung thực. Điều này có thể được thực hiện bằng bút và giấy hoặc bằng cách mua một máy tính có nhiều bộ nhớ hơn và trình biên dịch nhắm mục tiêu vào một kiến ​​trúc có nhiều bit hơn trên mỗi từ và cứ thế nếu chương trình hết bộ nhớ.

Điều này không hoạt động trong C vì không thể có một danh sách liên kết có thể phát triển mãi mãi: luôn có một số giới hạn về số lượng nút.

Để giải thích tại sao, trước tiên tôi cần giải thích việc triển khai C là gì. C thực sự là một gia đình của ngôn ngữ lập trình. Các tiêu chuẩn ISO C (chính xác hơn, một phiên bản cụ thể của tiêu chuẩn này) định nghĩa (với mức độ trịnh trọng rằng tiếng Anh cho phép) cú pháp và ngữ nghĩa một gia đình của các ngôn ngữ lập trình. C có rất nhiều hành vi không xác định và hành vi được xác định thực hiện. Một triển khai của CĐT của C của C mã hóa tất cả các hành vi được xác định thực hiện (danh sách những điều cần mã hóa nằm trong phụ lục J cho C99). Mỗi lần thực hiện C là một ngôn ngữ lập trình riêng. Lưu ý rằng ý nghĩa của từ triển khai trên ứng dụng, có một chút đặc biệt: ý nghĩa thực sự của nó là một biến thể ngôn ngữ, có thể có nhiều chương trình biên dịch khác nhau thực hiện cùng một biến thể ngôn ngữ.

$2^{\texttt{CHAR_BIT}}$t$2^{\texttt{CHAR_BIT} \times \texttt{sizeof(t)}}$

$2^{\texttt{CHAR_BIT} \times \texttt{sizeof(void*)}}$

Các giá trị của CHAR_BITvà sizeof(void*)có thể quan sát được, vì vậy nếu bạn hết bộ nhớ, bạn không thể tiếp tục chạy chương trình của mình với các giá trị lớn hơn cho các tham số đó. Bạn sẽ chạy chương trình theo một ngôn ngữ lập trình khác - triển khai C khác.

$n \times 2^{\texttt{CHAR_BIT} \times \texttt{sizeof(void*)}}$$n$

C không trực tiếp áp đặt độ sâu đệ quy tối đa. Việc triển khai được phép có tối đa, nhưng cũng được phép không có. Nhưng làm thế nào để chúng ta liên lạc giữa một cuộc gọi chức năng và cha mẹ của nó? Các đối số sẽ không tốt nếu chúng có thể truy cập được, bởi vì điều đó sẽ gián tiếp giới hạn độ sâu của đệ quy: nếu bạn có một hàm int f(int x) { … f(…) …}thì tất cả các lần xuất hiện xtrên các khung hoạt động fđều có địa chỉ riêng và do đó số lượng các cuộc gọi lồng nhau bị giới hạn bởi số địa chỉ có thể cho x.

Chương trình AC có thể sử dụng lưu trữ không có địa chỉ dưới dạng các registerbiến. Việc triển khai Bình thường chỉ có thể có một số lượng nhỏ các biến hữu hạn không có địa chỉ, nhưng về mặt lý thuyết, việc triển khai có thể cho phép một lượng registerlưu trữ không giới hạn . Trong quá trình triển khai như vậy, bạn có thể thực hiện một số lượng các cuộc gọi đệ quy không giới hạn cho một hàm, miễn là đối số của nó là register. Nhưng vì các đối số là register, bạn không thể tạo một con trỏ cho chúng và vì vậy bạn cần sao chép dữ liệu của chúng xung quanh một cách rõ ràng: bạn chỉ có thể truyền xung quanh một lượng dữ liệu hữu hạn, không phải là cấu trúc dữ liệu có kích thước tùy ý được tạo từ con trỏ.

Với độ sâu đệ quy không giới hạn và hạn chế rằng một hàm chỉ có thể lấy dữ liệu từ người gọi trực tiếp ( registerđối số) và trả lại dữ liệu cho người gọi trực tiếp (giá trị trả về của hàm), bạn có được sức mạnh của tự động đẩy xuống xác định .

Tôi không thể tìm cách đi xa hơn.

(Tất nhiên bạn có thể làm cho chương trình lưu trữ nội dung băng từ bên ngoài, thông qua các chức năng nhập / xuất tệp. Nhưng sau đó bạn sẽ không hỏi liệu C đã hoàn thành Turing chưa, nhưng liệu C cộng với một hệ thống lưu trữ vô hạn có hoàn chỉnh không, Turing mà câu trả lời là nhàm chán, đúng vậy. Bạn cũng có thể định nghĩa bộ lưu trữ là một lời tiên tri Turing - gọi  fopen("oracle", "r+"), fwritenội dung băng ban đầu cho nó và freadquay lại nội dung băng cuối cùng.)

Việc bổ sung va_copyAPI của C99 vào API đối số biến đổi có thể cho chúng ta một cánh cửa trở lại cho tính đầy đủ của Turing. Vì nó có thể lặp lại thông qua một danh sách các đối số biến đổi nhiều lần trong một hàm khác với hàm ban đầu nhận được các đối số, va_argscó thể được sử dụng để thực hiện một con trỏ không có con trỏ.

Tất nhiên, một triển khai thực sự của API đối số có thể sẽ có một con trỏ ở đâu đó, nhưng trong cỗ máy trừu tượng của chúng ta, nó có thể được thực hiện bằng phép thuật thay thế.

Đây là bản demo thực hiện tự động đẩy xuống 2 ngăn với các quy tắc chuyển đổi tùy ý:

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

Lưu ý: Nếu va_listlà một kiểu mảng, thì thực sự có các tham số con trỏ ẩn cho các hàm. Vì vậy, có lẽ sẽ tốt hơn nếu thay đổi loại của tất cả các va_listđối số thành wrapped_stack.

Số học không chuẩn, có thể?

Vì vậy, có vẻ như vấn đề là kích thước hữu hạn sizeof(t). Tuy nhiên, tôi nghĩ rằng tôi biết một công việc xung quanh.

Theo tôi biết, C không yêu cầu triển khai để sử dụng các số nguyên tiêu chuẩn cho loại số nguyên của nó. Do đó, chúng ta có thể sử dụng một mô hình số học không chuẩn . Sau đó, chúng tôi sẽ đặt sizeof(t)thành một số không chuẩn, và bây giờ chúng tôi sẽ không bao giờ đạt được nó trong một số bước hữu hạn. Do đó, độ dài của băng máy Turing sẽ luôn nhỏ hơn "tối đa", vì mức tối đa theo nghĩa đen là không thể đạt được. sizeof(t)đơn giản không phải là một số theo nghĩa thông thường của từ này.

Tất nhiên đây là một kỹ thuật: định lý của Tennenbaum . Nó nói rằng mô hình duy nhất của số học Peano là mô hình chuẩn, điều này rõ ràng sẽ không làm được. Tuy nhiên, theo như tôi biết, C không yêu cầu triển khai sử dụng các kiểu dữ liệu thỏa mãn các tiên đề Peano và cũng không yêu cầu việc thực hiện phải tính toán được, vì vậy đây không phải là vấn đề.

Điều gì sẽ xảy ra nếu bạn cố gắng xuất một số nguyên không chuẩn? Chà, bạn có thể biểu diễn bất kỳ số nguyên không chuẩn nào bằng chuỗi không chuẩn, vì vậy chỉ cần truyền các chữ số từ phía trước chuỗi đó.

IMO, một hạn chế mạnh mẽ là không gian địa chỉ (thông qua kích thước con trỏ) là hữu hạn và điều này là không thể phục hồi.

Người ta có thể biện hộ rằng bộ nhớ có thể được "hoán đổi sang đĩa", nhưng tại một số điểm, thông tin địa chỉ sẽ tự vượt quá kích thước địa chỉ.

Trong thực tế, những hạn chế này không liên quan đến tính đầy đủ của Turing. Yêu cầu thực sự là cho phép băng dài tùy ý, không vô hạn. Điều đó sẽ tạo ra một vấn đề tạm dừng của một loại khác (vũ trụ "tính toán" băng như thế nào?)

Điều đó là không có thật khi nói rằng "Python không hoàn thành Turing vì bạn không thể tạo một danh sách lớn vô cùng".

[Chỉnh sửa: cảm ơn ông Whitledge đã làm rõ cách chỉnh sửa.]

Phương tiện di động cho phép chúng ta tránh được vấn đề bộ nhớ không giới hạn. Có lẽ mọi người sẽ nghĩ rằng đây là một sự lạm dụng, nhưng tôi nghĩ dù sao cũng không thể tránh khỏi.

Sửa chữa bất kỳ thực hiện của một máy Turing phổ quát. Đối với băng, chúng tôi sử dụng phương tiện di động. Khi đầu chạy hết đầu hoặc đầu đĩa hiện tại, máy sẽ nhắc người dùng chèn đĩa tiếp theo hoặc trước đó. Chúng ta có thể sử dụng một điểm đánh dấu đặc biệt để biểu thị đầu bên trái của băng mô phỏng hoặc có một băng không bị ràng buộc theo cả hai hướng.

Điểm mấu chốt ở đây là mọi thứ mà chương trình C phải làm là hữu hạn. Máy tính chỉ cần đủ bộ nhớ để mô phỏng máy tự động, và size_tchỉ cần đủ lớn để cho phép giải quyết lượng bộ nhớ (thực sự khá nhỏ) và trên các đĩa, có thể có kích thước hữu hạn cố định. Vì người dùng chỉ được nhắc chèn đĩa tiếp theo hoặc trước đó, chúng tôi không cần số nguyên lớn không giới hạn để nói "Vui lòng chèn số đĩa 123456 ..."

Tôi cho rằng sự phản đối chính có khả năng liên quan đến người dùng nhưng điều đó dường như là không thể tránh khỏi trong bất kỳ triển khai nào, bởi vì dường như không có cách nào khác để thực hiện bộ nhớ không bị ràng buộc.

Chọn size_tlà vô cùng lớn

Bạn có thể chọn size_tlà vô cùng lớn. Đương nhiên, không thể nhận ra việc thực hiện như vậy. Nhưng điều đó không có gì đáng ngạc nhiên, do tính chất hữu hạn của thế giới chúng ta đang sống.

Ý nghĩa thực tiễn

Nhưng ngay cả khi có thể nhận ra việc thực hiện như vậy, sẽ có những vấn đề thực tế. Hãy xem xét các tuyên bố C sau đây:

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

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

May mắn thay, vì mục đích lý thuyết của chúng tôi, tôi không thể tìm thấy bất kỳ yêu cầu nào trong đặc điểm kỹ thuật đảm bảo printfsẽ chấm dứt cho tất cả các đầu vào. Vì vậy, theo như tôi biết, chúng tôi không vi phạm đặc điểm kỹ thuật C ở đây.

Về tính đầy đủ tính toán

Vẫn còn phải chứng minh rằng việc thực hiện lý thuyết của chúng tôi là Turing Complete . Chúng tôi có thể hiển thị điều này bằng cách triển khai "bất kỳ máy Turing nào được gõ một lần".

Hầu hết chúng ta có lẽ đã thực hiện Turing Machine như một dự án trường học. Tôi sẽ không cung cấp chi tiết về cách triển khai cụ thể, nhưng đây là một chiến lược thường được sử dụng:

• Số lượng trạng thái, số ký hiệu và bảng chuyển trạng thái được cố định cho bất kỳ máy nào. Vì vậy, chúng ta có thể biểu diễn các trạng thái và ký hiệu dưới dạng số và bảng chuyển trạng thái dưới dạng mảng 2 chiều.
• Các băng có thể được đại diện như một danh sách liên kết. Chúng ta có thể sử dụng một danh sách liên kết đôi hoặc hai danh sách liên kết đơn (một cho mỗi hướng từ vị trí hiện tại).

Bây giờ hãy xem những gì cần thiết để nhận ra một triển khai như vậy:

• Khả năng đại diện cho một số bộ số cố định, nhưng lớn tùy ý. Để đại diện cho bất kỳ số tùy ý, chúng tôi chọn MAX_INTlà vô hạn. (Ngoài ra, chúng ta có thể sử dụng các đối tượng khác để thể hiện các trạng thái và ký hiệu.)
• Khả năng xây dựng một danh sách liên kết lớn tùy ý cho băng của chúng tôi. Một lần nữa, không có giới hạn hữu hạn về kích thước. Điều này có nghĩa là chúng tôi không thể xây dựng danh sách này trước, vì chúng tôi sẽ dành mãi mãi chỉ để xây dựng băng của chúng tôi. Nhưng, chúng ta có thể xây dựng danh sách này dần dần nếu chúng ta sử dụng cấp phát bộ nhớ động. Chúng ta có thể sử dụng malloc, nhưng chúng ta phải xem xét thêm một chút nữa:
  • Đặc tả C cho phép mallocthất bại nếu, ví dụ, bộ nhớ khả dụng đã cạn kiệt. Vì vậy, việc thực hiện của chúng tôi chỉ thực sự phổ quát nếu mallockhông bao giờ thất bại.
  • Tuy nhiên, nếu việc triển khai của chúng tôi được chạy trên một máy có bộ nhớ vô hạn, thì không cần phải mallocthất bại. Không vi phạm tiêu chuẩn C, việc thực hiện của chúng tôi sẽ đảm bảo rằng mallocsẽ không bao giờ thất bại.
• Khả năng xác định con trỏ, tìm kiếm các phần tử mảng và truy cập các thành viên của một nút danh sách được liên kết.

Vì vậy, danh sách trên là những gì cần thiết để triển khai Máy Turing trong triển khai C giả định của chúng tôi. Các tính năng này phải chấm dứt. Tuy nhiên, bất cứ điều gì khác, có thể được phép không chấm dứt (trừ khi tiêu chuẩn yêu cầu). Điều này bao gồm số học, IO, v.v.

Đối số chính ở đây là kích thước của size_t là hữu hạn, mặc dù có thể vô cùng lớn.

Có một cách giải quyết cho nó, mặc dù tôi không chắc liệu điều này có trùng với ISO C.

Giả sử bạn có một máy có bộ nhớ vô hạn. Do đó, bạn không bị giới hạn kích thước con trỏ. Bạn vẫn có loại size_t của bạn. Nếu bạn hỏi tôi sizeof (size_t) là gì thì câu trả lời sẽ chỉ là sizeof (size_t). Nếu bạn hỏi nếu nó lớn hơn 100 chẳng hạn thì câu trả lời là có. Nếu bạn hỏi sizeof (size_t) / 2 là gì thì bạn có thể đoán câu trả lời vẫn là sizeof (size_t). Nếu bạn muốn in nó, chúng tôi có thể đồng ý về một số đầu ra. Sự khác biệt của hai có thể là NaN và như vậy.

Tóm tắt là việc nới lỏng điều kiện cho size_t có kích thước hữu hạn sẽ không phá vỡ bất kỳ chương trình nào đã tồn tại.

PS Phân bổ kích thước bộ nhớ (size_t) vẫn có thể, bạn chỉ cần kích thước có thể đếm được, vì vậy giả sử bạn lấy tất cả evens (hoặc thủ thuật tương tự).

Đúng vậy

1. Trích dẫn câu trả lời

Như một phản ứng về số lượng downvote cao đối với các câu trả lời đúng của tôi (và khác) - so với sự chấp thuận cao đáng báo động của các câu trả lời sai - tôi đã tìm kiếm một lời giải thích thay thế ít sâu sắc về mặt lý thuyết. Tôi tìm thấy này một. Tôi hy vọng nó bao gồm một số sai lầm phổ biến ở đây, để một cái nhìn sâu sắc hơn được hiển thị. Phần thiết yếu của lập luận:

[...] Lập luận của anh ấy như sau: giả sử người ta đã viết một chương trình chấm dứt nhất định có thể yêu cầu, trong quá trình thực thi, lên đến một số lượng lưu trữ tùy ý. Không thay đổi chương trình đó, có thể một posteriori thực hiện một phần cứng máy tính và trình biên dịch C của nó cung cấp đủ dung lượng để chứa tính toán này. Điều này có thể yêu cầu mở rộng độ rộng của char (thông qua CHAR_BITS) và / hoặc con trỏ (thông qua size_t), nhưng chương trình sẽ không cần phải sửa đổi. Bởi vì điều này là có thể, C thực sự là Turing-Complete để chấm dứt các chương trình.

Phần khó khăn của lập luận này là nó chỉ hoạt động khi xem xét chấm dứt các chương trình. Các chương trình kết thúc có thuộc tính tốt này là chúng có giới hạn trên tĩnh đối với yêu cầu lưu trữ của chúng, người ta có thể xác định bằng thực nghiệm bằng cách chạy chương trình qua đầu vào mong muốn với kích thước lưu trữ tăng dần, cho đến khi nó phù hợp.

Lý do tại sao tôi đã đánh lạc hướng trong suy nghĩ của mình rằng tôi đang xem xét lớp rộng hơn của các chương trình không kết thúc có ích của [[]]

Nói tóm lại, vì đối với mọi hàm tính toán đều có một giải pháp trong ngôn ngữ C (do giới hạn trên không giới hạn), mọi vấn đề tính toán đều có chương trình C, do đó C hoàn thành Turing.

2. Câu trả lời ban đầu của tôi

Có sự nhầm lẫn phổ biến giữa các khái niệm toán học trong khoa học máy tính lý thuyết (chẳng hạn như Turing-đầy đủ) và ứng dụng trong thế giới thực của chúng, tức là các kỹ thuật trong khoa học máy tính thực tế. Turing-đầy đủ không phải là một tài sản của các máy hiện có hoặc bất kỳ mô hình giới hạn không thời gian nào. Nó chỉ là một đối tượng trừu tượng mô tả các thuộc tính của các lý thuyết toán học.

C99 hoàn thành Turing bất kể các hạn chế dựa trên triển khai, giống như hầu hết các ngôn ngữ lập trình phổ biến khác, vì nó có thể diễn đạt một tập hợp các kết nối logic đầy đủ chức năng và có quyền truy cập vào bộ nhớ không giới hạn. Mọi người đã chỉ ra rằng C hạn chế truy cập bộ nhớ ngẫu nhiên một cách rõ ràng bị hạn chế, nhưng điều này không có gì là không thể tránh được, vì đây là những hạn chế được nêu thêm trong tiêu chuẩn C, trong khi tính đầy đủ của Turing không có:

Đây là một điều rất cơ bản về các hệ thống logic nên đủ cho một bằng chứng không mang tính xây dựng . Hãy xem xét một phép tính với một số sơ đồ và quy tắc tiên đề, sao cho tập hợp các điều kiện logic là X. Bây giờ nếu bạn thêm một số quy tắc hoặc tiên đề, tập hợp các hậu quả logic sẽ phát triển, ví dụ: phải là siêu bộ của X. , logic phương thức S4 được chứa đúng trong S5. Tương tự, khi bạn có một đặc tả con là Turing-Complete, nhưng bạn thêm một số hạn chế lên trên, những điều này không ngăn chặn bất kỳ hậu quả nào trong X, tức là phải có cách để tránh tất cả các hạn chế. Nếu bạn muốn một ngôn ngữ không hoàn chỉnh, tính toán phải được giảm bớt, không được mở rộng. Các phần mở rộng tuyên bố rằng một cái gì đó sẽ không thể, nhưng thực tế là, chỉ thêm sự không nhất quán. Những sự không nhất quán trong tiêu chuẩn C có thể không mang lại hậu quả thực tế nào, giống như tính hoàn chỉnh của Turing không liên quan đến ứng dụng thực tế.

Mô phỏng các số tùy ý dựa trên độ sâu đệ quy (nghĩa là này , với khả năng hỗ trợ nhiều số thông qua lập lịch / giả mã; không có giới hạn lý thuyết nào cho độ sâu đệ quy trong C ) hoặc sử dụng lưu trữ tệp để mô phỏng bộ nhớ chương trình không giới hạn ( ý tưởng ) có lẽ chỉ có hai trong số các khả năng vô hạn để chứng minh một cách xây dựng tính hoàn chỉnh của C99. Chúng ta nên nhớ rằng đối với khả năng tính toán, thời gian và độ phức tạp không gian là không liên quan. Cụ thể, giả sử một môi trường hạn chế để làm sai lệch tính đầy đủ của Turing chỉ là lý do vòng tròn vì giới hạn đó loại trừ tất cả các vấn đề vượt quá độ phức tạp giả định trước.

( LƯU Ý : Tôi chỉ viết câu trả lời này để ngăn mọi người dừng lại để có được trực giác toán học do một số loại suy nghĩ hạn chế theo định hướng ứng dụng. Thật đáng tiếc khi hầu hết người học sẽ đọc câu trả lời sai được chấp nhận do nó được đưa lên dựa trên sai sót cơ bản của lý luận, để nhiều người sẽ truyền bá niềm tin sai lầm như vậy. Nếu bạn hạ thấp câu trả lời này, bạn chỉ là một phần của vấn đề.)