Re: Who here understands that the last paragraph is Necessarily true? --- Self-Modifying Turing Machine

On 7/19/24 12:02 PM, olcott wrote:

On 7/19/2024 10:53 AM, joes wrote:

Am Fri, 19 Jul 2024 09:18:05 -0500 schrieb olcott:

On 7/19/2024 2:49 AM, Mikko wrote:

On 2024-07-17 13:22:09 +0000, olcott said:

On 7/17/2024 2:32 AM, Mikko wrote:

On 2024-07-16 14:04:18 +0000, olcott said:

On 7/16/2024 6:53 AM, Richard Damon wrote:

On 7/15/24 10:51 PM, olcott wrote:

On 7/15/2024 2:40 PM, olcott wrote:

On 7/15/2024 2:30 PM, Fred. Zwarts wrote:

Op 15.jul.2024 om 04:33 schreef olcott:

On 7/14/2024 9:04 PM, Richard Damon wrote:

On 7/14/24 9:27 PM, olcott wrote:

>

Can't. Since programs are unchanging, their properties can not
change.

Your complier cannot produce self-modifying code.

My compiler can accept assembly language that can derive
self-modifying code.

Using non-standard extensions of the language may indeed permit that
unless the program is loaded to a read-only memory. The compiler is
designed so that ordinary programs can be loaded to read-only memory.
Some operating systems prevent programs from modifying themselves as if
the program were in a read-only memory, and typical compilers compile
so that the program can be run under such operating systems.

The bottom line is that an actual TM can modify its own code while it is
running when it has access to its own TM description and it is only
simulated by a UTM. In this case it can modify itself so that its input
is no longer contradictory.

Oh no. A running TM cannot change its transition table.

 A Self-Modifying Turing Machine is defined as a Turing
Machine Description that has access to its own tape
location on the UTM that is simulating it.

But Turing Machines don't have access to their description.
And your "UTM" isn't actually a UTM, as a UTM, by its definition, doesn't give the Turing Machine Description on the tape access to that part of the tape, as that isn't how Turing Machines work.
And that description on the tape isn't the description of an actual Turing Machine, as you seem to presume the thing thinks it has access to its description.
SO, NOTHING in that system is what you claimed it to be.
Now, you COULD define a Turing Machine that is something similar to a UTM, but not constrained to be exactly one that processes an input that has a description of an algorithm in a way similar to how you would describe it to a UTM, but with the understanding that it will be able to access its own description, and then interpret that part of the input as it processes the data.
The first big problem is that Turing Machines (and things that work by similar rules are you "self-Modifying Turing Machine Description") are slow at manipulating complicated data, and thus there is the difficulty of maintaining a valid description (at least valid enough to let the actual interpreter keep running correctly) on the tape while updating the description.
The second thing to point out is all this does is prove that since what we now have is an ACTUAL STANDARD TM processing this tape, and said TM could be prepended with code to insert onto the tape the representation of the "self-modifying machine description", all you have done is demonstart that your idea of a "Self-Modifying Turing Machine" can't actually do anything that a "normal" TM couldn't do, but may have lost some of the basic properties that simplify how we can prove things with them, means you concept isn't actually that useful.

 

Even then,
its description would include the selfmodification.
Being simulated does not change anything, as the simulated machine
is not aware of that.

When a Self-Modifying Turing Machine can change itself to become any
other Turing Machine then it can eliminate the pathological relationship
to its input.

I think not, because the selfmodification is built into it. It is
different from the version that doesn't have that.
>