The last line of this page

The title of this article is not correct because of technical limitations. The correct title is actually [[Category:No-code esolang]] [[Category:Unimplemented]].

[[Category:No-code esolang]] [[Category:Unimplemented]] is a no-code esolang. However, while these are usually easy to interpret, this language is impossible to interpret (though it's very easy to get close). This is not just true due to uncomputability, as it is also equally as impossible for Banana Scheme.

Specification

The program must be specified as a string, and outputs a string. Each program is ignored, and the output will be a program that the interpreter does not interpret correctly. This may differ based on the program. As which programs are not interpreted correctly depends on the interpreter, all programs are implementation-dependent.

Potentially paradoxical programs

Of course, if a program outputs itself, this may cause a problem. If the program is interpreted correctly, it outputs a correctly interpreted program, so the program does not interpret the program correctly, which is a contradiction. However, if the program is not interpreted correctly, it outputs the program is not interpreted correctly. This does not necessarily mean that the program is interpreted correctly, however it is unclear where the program's implementation deviates from the specification in this case, thus calling it paradoxical is logical. Similar situations happen for any odd-length chain of programs that output the next program in the chain. Therefore, it is implementation-defined whether these are simply not interpreted correctly or are some paradoxical class of programs. One thing to note is that if the program is paradoxical, any programs that output it must be counted as not being interpreted correctly, as the output is not a program that is not interpreted correctly.

Circular programs

Similar to potentially paradoxical programs, there may also be circular programs. For example, say a potential interpreter given 0 outputs 1 and 1 outputs 0. Here, you can say either 0 is correctly interpreted while 1 is not interpreted correctly, or 0 is not interpreted correctly while 1 is interpreted correctly.

Proof of uninterpretability

This is a proof that any interpreter fails for at least one program. Take any program A and let its output be B. B must either be interpreted correctly or not interpreted correctly. If it is interpreted correctly, A does not output a program that the interpreter does not interpret correctly, thus A is not interpreted correctly. If it is interpreted incorrectly, B is not interpreted correctly. Therefore, there is at least one program that is not interpreted correctly.

Near-interpreters

While it is impossible to fully interpret the language, it is very much possible to nearly interpret the language. All interpreters for Do nothing can be considered a near-interpreter that only fails on the empty program if you consider paradoxical programs to simply not be interpreted correctly. Similar for Nope. interpreters and the program Nope.. However, since these rely on the behavior of potentially paradoxical programs, the nearness of these interpreters is disputable. Here is an undisputably correct program in FALSE:

^48=.

This outputs 0 for every program except 0, which outputs -1.