Quines (again)

I personally rate this as the best page on the internet:

http://www.madore.org/~david/computers/quine.html

Just reading again its directly relevant to SRH.

The key "magic" in the SRH, Horatio Principle, +1 Principle etc and even my analysis of Betty Blue is exactly the problem faced in a Quine where the program must output the current line of code.

In a function there is the operation code instructions saying what "to do", and then the data which is operated on and "done to". In a simple 1D program then there is always more instruction than data so a quine is impossible.

To get around this hidden memory is used. By assigning and binding data to variables, we can use those variables to refer to other things. This way there are 2 ways to refer to the data: the data itself and its name. By switching between these ways of referring to the data we can apparently side step the SRH.

At assignment the data is given a name. And then afterwards the name is used. The data is the critical part because it must appear in the output. Every time we write the data in code it must replicate in the output. Because data appears unchanged in the output we are stuck because every occurrence of the data in output must occur in the code which leaves no room for the +1 instructions.

But writing a variable to output only requires the variable name, yet the output is whatever is stored in the variable which if larger than the variable name gives a way for the output to jump ahead of the executing code and so avoid the issue of printing the current line. Already stored in the variable is the line using the variable name, which will be executed in the future to print what is stored. This figure eight get around all the problems.

In SRH we are saying that a system cannot contain itself. Now take a system that is two copies of something. And if that something is instructions to replicate itself, then each half actually means the whole.

However SRH is saying that this is cheating. In a quine a system stores data in a variable that cannot be seen in the code. The "name" is used and magically refers to the "hidden" data. In SRH this hidden data is really part of the system state.

The SRH analogy then is not a program which outputs its own code listing. But, rather a system which can represent its own static system state. Not temporarily where we can assign to a variable  now and then forget about that assignment and use the name in the future. But statically where the whole state is concurrently present.

Suppose this was represented in a flow diagram. To contradict SRH we would need a flow diagram which represented itself. Not trivially like printing out the source code, but at the level of the logic itself.

I am struggling here to express the difference between data hidden behind a variable, and a system with nothing hidden. Self-reference in its fullest sense cannot delegate reference to the self onto a name which is not-self. The whole point of SRH is that we are denying the existence of an entity referring to its self, rather than a box which we've been told, and must remember, contains it.

Perhaps coin this: self-evident  self-reference SESR

In Godel and other self-reference diagonalisation proofs there is isomorphism between two systems. It can be show then that a statement in one system contradicts its partner in the other system. For example the statement number #123 is false. And then we see that this statement is #123. But it depends upon an agent to help us out and point out the contradiction.

self-reference is more problematic than that. "I am a lie" requires no isomorphism. Its not obliquely referring to itself, the reference is intrinsic to the meaning. Statement #123 is false can be understood without realising that there is a contradiction. We are simply making a statement about some statement. we can fully construct that statement and then later see if its a contradiction. "I am a lie" cannot be constructed without creating the contradiction.

Likewise Russel's Paradox cannot be constructed without creating a contradiction.

So self-reference is no reference that happens to be to oneself. Godel is a construction based upon reference which happens to be self reference. But for SRH we want a construction based upon self-reference. That is true self reference.