The reason that people assume that H1(D,D) must get
the same result as H(D,D) is that they make sure
to ignore the reason why they get a different result.

It turns out that the only reason that H1(D,D) derives a
different result than H(D,D) is that H is at a different
physical machine address than H1.

D calls 00001522 // machine address of H
thus D does call 00001422 // machine address of H1

Since this <is> the empirically determined deciding
factor I don't think that it can be correctly ignored.

Any physically implemented Turing machine must exist
at some physical memory location.

It is conventional to ignore this yet when it proves
to be the deciding factor then it is proven that it
cannot be correctly ignored.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

That means that any physically existing H is at a
different memory location than Ĥ.H.

We can imagine square roots of negative numbers.
What we cannot do is imagine them fitting coherently
into the rest of mathematics.

I don't think that a machine architecture such that
every machine can always get its own machine address
breaks this. https://en.wikipedia.org/wiki/Pure_function
*Someone on this forum agreed to that at some point*

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/24 5:28 PM, olcott wrote:
> The reason that people assume that H1(D,D) must get
> the same result as H(D,D) is that they make sure
> to ignore the reason why they get a different result.

Namely that you are lying that H and H1 are actually the same computation.

>
> It turns out that the only reason that H1(D,D) derives a
> different result than H(D,D) is that H is at a different
> physical machine address than H1.

Which means that H and H1 are not computations, and you have been just
an ignorant pathological liar all this time.

>
> D calls 00001522 // machine address of H
> thus D does call 00001422 // machine address of H1
>
> Since this <is> the empirically determined deciding
> factor I don't think that it can be correctly ignored.

Right, but since the algorithm for H/H1 uses the address of the decider,
which isn't defined as an "input" to it, we see that you have been lying
that this code is a computation. Likely because you have made yourself
ignorant of what a computation actually is,

Thus you have made yourself into an Ignorant Pathological Lying Idiot.

>
> Any physically implemented Turing machine must exist
> at some physical memory location.

Nope.

Just proves you don't understand what a "Turing Machine" is.

>
> It is conventional to ignore this yet when it proves
> to be the deciding factor then it is proven that it
> cannot be correctly ignored.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> That means that any physically existing H is at a
> different memory location than Ĥ.H.

Ok, but it isn't allowed to use that address as part of its logic.

>
> We can imagine square roots of negative numbers.
> What we cannot do is imagine them fitting coherently
> into the rest of mathematics.

Sure we can.

>
> I don't think that a machine architecture such that
> every machine can always get its own machine address
> breaks this.  https://en.wikipedia.org/wiki/Pure_function
> *Someone on this forum agreed to that at some point*
>

it breaks the definition of a "Computation" if two supposed identical
copies use it to act differently.

You are just continuing to prove that you are just an ignorant
pathological lying idiot.

On 3/2/2024 4:54 PM, Richard Damon wrote:
> On 3/2/24 5:28 PM, olcott wrote:
>> The reason that people assume that H1(D,D) must get
>> the same result as H(D,D) is that they make sure
>> to ignore the reason why they get a different result.
>
> Namely that you are lying that H and H1 are actually the same computation.
>
>>
>> It turns out that the only reason that H1(D,D) derives a
>> different result than H(D,D) is that H is at a different
>> physical machine address than H1.
>
> Which means that H and H1 are not computations, and you have been just
> an ignorant pathological liar all this time.
>
>>
>> D calls 00001522 // machine address of H
>> thus D does call 00001422 // machine address of H1
>>
>> Since this <is> the empirically determined deciding
>> factor I don't think that it can be correctly ignored.
>
> Right, but since the algorithm for H/H1 uses the address of the decider,
> which isn't defined as an "input" to it, we see that you have been lying
> that this code is a computation. Likely because you have made yourself
> ignorant of what a computation actually is,
>
> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>
>>
>> Any physically implemented Turing machine must exist
>> at some physical memory location.
>
> Nope.
Any *physically implemented Turing machine*
*physically implemented Turing machine*
*physically implemented Turing machine*
*physically implemented Turing machine*
must exist at some physical memory location.

Try and explain the details of how it can be otherwise.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 2/03/24 23:28, olcott wrote:
> The reason that people assume that H1(D,D) must get
> the same result as H(D,D) is that they make sure
> to ignore the reason why they get a different result.
>
> It turns out that the only reason that H1(D,D) derives a
> different result than H(D,D) is that H is at a different
> physical machine address than H1.

Incorrect - the reason that H1(D,D) derives a different result is that H
*looks for* a different physical machine address than H1. If H1 was at
the same address it is now, but looked for the address of H, just like H
does, then it would actually be identical, and would return the same result.

> Any physically implemented Turing machine must exist
> at some physical memory location.
But has no way to know it. Turing machine H1 doesn't know whether it's H
or H1.

On 3/2/2024 5:15 PM, immibis wrote:
> On 2/03/24 23:28, olcott wrote:
>> The reason that people assume that H1(D,D) must get
>> the same result as H(D,D) is that they make sure
>> to ignore the reason why they get a different result.
>>
>> It turns out that the only reason that H1(D,D) derives a
>> different result than H(D,D) is that H is at a different
>> physical machine address than H1.
>
> Incorrect - the reason that H1(D,D) derives a different result is that H
> *looks for* a different physical machine address than H1.

_D()
[00001cf2] 55 push ebp
[00001cf3] 8bec mov ebp,esp
[00001cf5] 51 push ecx
[00001cf6] 8b4508 mov eax,[ebp+08]
[00001cf9] 50 push eax
[00001cfa] 8b4d08 mov ecx,[ebp+08]
[00001cfd] 51 push ecx
[00001cfe] e81ff8ffff call 00001522 ; call to H
....

*That is factually incorrect*
H and H1 simulate the actual code of D which actually
calls H at machine address 00001522 and does not call
H1 at machine address 00001422.

> If H1 was at
> the same address it is now, but looked for the address of H, just like H
> does, then it would actually be identical, and would return the same
> result.
>
>> Any physically implemented Turing machine must exist
>> at some physical memory location.
> But has no way to know it. Turing machine H1 doesn't know whether it's H
> or H1.
>

H and H1 simulate the actual code of D which actually
calls H at machine address 00001522 and does not call
H1 at machine address 00001422.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

Ĥ actually transitions to its own internal state Ĥ.H
thus does not transition to the external H.q0

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/2024 4:54 PM, Richard Damon wrote:
> On 3/2/24 5:28 PM, olcott wrote:
>> The reason that people assume that H1(D,D) must get
>> the same result as H(D,D) is that they make sure
>> to ignore the reason why they get a different result.
>
> Namely that you are lying that H and H1 are actually the same computation.
>
>>
>> It turns out that the only reason that H1(D,D) derives a
>> different result than H(D,D) is that H is at a different
>> physical machine address than H1.
>
> Which means that H and H1 are not computations, and you have been just
> an ignorant pathological liar all this time.
>
>>
>> D calls 00001522 // machine address of H
>> thus D does call 00001422 // machine address of H1
>>
>> Since this <is> the empirically determined deciding
>> factor I don't think that it can be correctly ignored.
>
> Right, but since the algorithm for H/H1 uses the address of the decider,

_D()
[00001cf2] 55 push ebp
[00001cf3] 8bec mov ebp,esp
[00001cf5] 51 push ecx
[00001cf6] 8b4508 mov eax,[ebp+08]
[00001cf9] 50 push eax
[00001cfa] 8b4d08 mov ecx,[ebp+08]
[00001cfd] 51 push ecx
[00001cfe] e81ff8ffff call 00001522 ; call H
....

No matter what criteria that any termination analyzer uses
it is an empirically verified fact that D does call H and
does not call H1.

Because of this empirically verified fact it is entailed
that if H(D,D) does not abort its simulation that H would
never terminate.

By this same empirically verified fact if H(D,D) does abort its
simulation (for any reason) then when H1(D,D) correctly simulates
D(D) it correctly reports on the actual behavior of D(D).

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/2024 4:54 PM, Richard Damon wrote:
> On 3/2/24 5:28 PM, olcott wrote:
>> The reason that people assume that H1(D,D) must get
>> the same result as H(D,D) is that they make sure
>> to ignore the reason why they get a different result.
>
> Namely that you are lying that H and H1 are actually the same computation.
>
>>
>> It turns out that the only reason that H1(D,D) derives a
>> different result than H(D,D) is that H is at a different
>> physical machine address than H1.
>
> Which means that H and H1 are not computations, and you have been just
> an ignorant pathological liar all this time.
>
>>
>> D calls 00001522 // machine address of H
>> thus D does call 00001422 // machine address of H1
>>
>> Since this <is> the empirically determined deciding
>> factor I don't think that it can be correctly ignored.
>
> Right, but since the algorithm for H/H1 uses the address of the decider,
> which isn't defined as an "input" to it, we see that you have been lying
> that this code is a computation. Likely because you have made yourself
> ignorant of what a computation actually is,
>
> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>
>>
>> Any physically implemented Turing machine must exist
>> at some physical memory location.
>
> Nope.
>
> Just proves you don't understand what a "Turing Machine" is.
>
>>
>> It is conventional to ignore this yet when it proves
>> to be the deciding factor then it is proven that it
>> cannot be correctly ignored.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> That means that any physically existing H is at a
>> different memory location than Ĥ.H.
>
> Ok, but it isn't allowed to use that address as part of its logic.
>
>>
>> We can imagine square roots of negative numbers.
>> What we cannot do is imagine them fitting coherently
>> into the rest of mathematics.
>
> Sure we can.
>
>>
>> I don't think that a machine architecture such that
>> every machine can always get its own machine address
>> breaks this.  https://en.wikipedia.org/wiki/Pure_function
>> *Someone on this forum agreed to that at some point*
>>
>
> it breaks the definition of a "Computation" if two supposed identical
> copies use it to act differently.
>

If an otherwise identical machine is at a different physical
address and this difference by itself actually causes H/D
to have different behavior than H1/D then these machine
input pairs are not actually identical even when they have
identical bytes.

Since we ourselves can see that H(D,D) would never stop
running unless aborted we ourselves can see the H must
abort its simulation to prevent its own non-termination.

I think that it is an error to assume that computers are
theoretically strictly less powerful than human minds.

I think that it is a big mistake to assume that computers
cannot see what we ourselves can clearly see.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/24 6:01 PM, olcott wrote:
> On 3/2/2024 4:54 PM, Richard Damon wrote:
>> On 3/2/24 5:28 PM, olcott wrote:
>>> The reason that people assume that H1(D,D) must get
>>> the same result as H(D,D) is that they make sure
>>> to ignore the reason why they get a different result.
>>
>> Namely that you are lying that H and H1 are actually the same
>> computation.
>>
>>>
>>> It turns out that the only reason that H1(D,D) derives a
>>> different result than H(D,D) is that H is at a different
>>> physical machine address than H1.
>>
>> Which means that H and H1 are not computations, and you have been just
>> an ignorant pathological liar all this time.
>>
>>>
>>> D calls 00001522 // machine address of H
>>> thus D does call 00001422 // machine address of H1
>>>
>>> Since this <is> the empirically determined deciding
>>> factor I don't think that it can be correctly ignored.
>>
>> Right, but since the algorithm for H/H1 uses the address of the
>> decider, which isn't defined as an "input" to it, we see that you have
>> been lying that this code is a computation. Likely because you have
>> made yourself ignorant of what a computation actually is,
>>
>> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>>
>>>
>>> Any physically implemented Turing machine must exist
>>> at some physical memory location.
>>
>> Nope.
> Any *physically implemented Turing machine*
> *physically implemented Turing machine*
> *physically implemented Turing machine*
> *physically implemented Turing machine*
> must exist at some physical memory location.
>
> Try and explain the details of how it can be otherwise.
>

And description of a Turing Machine (or a Computation) that needs to
reference atributes of Modern Electronic Computers is just WRONG as they
predate the development of such a thing.

A simple implementation of a Turing Machine that has nothing like a
"Memory Address" is a "Code Book", with the code for the Turing machine
divided into logical "pages", each with the instructions for one state
of the machine.

On each page is a listing for each input that could be on the tape, the
operation to do with the tape, including what symbol to write on the
current location of the tape, and what the next state to go to.

You then have a physical tape to write the symbols of tape, with
something to indicate the current position we are on the tape.

Thus starting on "page 0" (or whatever the starting state is) and
procesing the tape as instructed, and turning the pages as instructed,
you can run the Turing Machine to its final answer.

(If you want to claim the page number represents a Memory Address, then
you lose the fact that two different Turing Machine instances will have
different "Memory Addresse"

Remember, Turing Machines are not defined to be an "efficient" methods
of computation, but are a tool to determine WHAT CAN be computed. This
is primarily a MATHEMATICAL question, not a computerish question.

Computation Theory is part of Computer Science, not because it tells us
a lot about what Modern Computers can do, but out of the historical
background and the foundations it lays.

On 3/2/24 7:26 PM, olcott wrote:
> On 3/2/2024 4:54 PM, Richard Damon wrote:
>> On 3/2/24 5:28 PM, olcott wrote:
>>> The reason that people assume that H1(D,D) must get
>>> the same result as H(D,D) is that they make sure
>>> to ignore the reason why they get a different result.
>>
>> Namely that you are lying that H and H1 are actually the same
>> computation.
>>
>>>
>>> It turns out that the only reason that H1(D,D) derives a
>>> different result than H(D,D) is that H is at a different
>>> physical machine address than H1.
>>
>> Which means that H and H1 are not computations, and you have been just
>> an ignorant pathological liar all this time.
>>
>>>
>>> D calls 00001522 // machine address of H
>>> thus D does call 00001422 // machine address of H1
>>>
>>> Since this <is> the empirically determined deciding
>>> factor I don't think that it can be correctly ignored.
>>
>> Right, but since the algorithm for H/H1 uses the address of the
>> decider, which isn't defined as an "input" to it, we see that you have
>> been lying that this code is a computation. Likely because you have
>> made yourself ignorant of what a computation actually is,
>>
>> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>>
>>>
>>> Any physically implemented Turing machine must exist
>>> at some physical memory location.
>>
>> Nope.
>>
>> Just proves you don't understand what a "Turing Machine" is.
>>
>>>
>>> It is conventional to ignore this yet when it proves
>>> to be the deciding factor then it is proven that it
>>> cannot be correctly ignored.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> That means that any physically existing H is at a
>>> different memory location than Ĥ.H.
>>
>> Ok, but it isn't allowed to use that address as part of its logic.
>>
>>>
>>> We can imagine square roots of negative numbers.
>>> What we cannot do is imagine them fitting coherently
>>> into the rest of mathematics.
>>
>> Sure we can.
>>
>>>
>>> I don't think that a machine architecture such that
>>> every machine can always get its own machine address
>>> breaks this.  https://en.wikipedia.org/wiki/Pure_function
>>> *Someone on this forum agreed to that at some point*
>>>
>>
>> it breaks the definition of a "Computation" if two supposed identical
>> copies use it to act differently.
>>
>
> If an otherwise identical machine is at a different physical
> address and this difference by itself actually causes H/D
> to have different behavior than H1/D then these machine
> input pairs are not actually identical even when they have
> identical bytes.
>
> Since we ourselves can see that H(D,D) would never stop
> running unless aborted we ourselves can see the H must
> abort its simulation to prevent its own non-termination.
>
> I think that it is an error to assume that computers are
> theoretically strictly less powerful than human minds.
>
> I think that it is a big mistake to assume that computers
> cannot see what we ourselves can clearly see.
>

If the machine is an actual computation, then its memory address does
not affectd it.

Your logic is just wrong.

Note, Computers, as generally viewed, especiailly for "Compuation
Theory" have the limitation of being deterministic, whcih DOES make them
less powerful than the human mind, which has free will.

Comuputers can only "See" what there programming has defined they are
able to see.

On 3/2/24 6:25 PM, olcott wrote:
> On 3/2/2024 5:15 PM, immibis wrote:
>> On 2/03/24 23:28, olcott wrote:
>>> The reason that people assume that H1(D,D) must get
>>> the same result as H(D,D) is that they make sure
>>> to ignore the reason why they get a different result.
>>>
>>> It turns out that the only reason that H1(D,D) derives a
>>> different result than H(D,D) is that H is at a different
>>> physical machine address than H1.
>>
>> Incorrect - the reason that H1(D,D) derives a different result is that
>> H *looks for* a different physical machine address than H1.
>
> _D()
> [00001cf2] 55         push ebp
> [00001cf3] 8bec       mov ebp,esp
> [00001cf5] 51         push ecx
> [00001cf6] 8b4508     mov eax,[ebp+08]
> [00001cf9] 50         push eax
> [00001cfa] 8b4d08     mov ecx,[ebp+08]
> [00001cfd] 51         push ecx
> [00001cfe] e81ff8ffff call 00001522 ; call to H
> ...
>
> *That is factually incorrect*
> H and H1 simulate the actual code of D which actually
> calls H at machine address 00001522 and does not call
> H1 at machine address 00001422.

Which proves that H and H1 are not the "Same Computation" (if they are
computations at all)

THus you have admitted that you have LIED about the construction of D as
the equivalent to Linz H^, as that is based on the H that is deciding
it, and which MUST be a computation.

>
>> If H1 was at the same address it is now, but looked for the address of
>> H, just like H does, then it would actually be identical, and would
>> return the same result.
>>
>>> Any physically implemented Turing machine must exist
>>> at some physical memory location.
>> But has no way to know it. Turing machine H1 doesn't know whether it's
>> H or H1.
>>
>
> H and H1 simulate the actual code of D which actually
> calls H at machine address 00001522 and does not call
> H1 at machine address 00001422.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn     // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Ĥ actually transitions to its own internal state Ĥ.H
> thus does not transition to the external H.q0
>

In other words, you are admitting that you are totallyu ignorant of the
principles of Computation Theory.

Apparently INTENTIONALLY IGNORANT so you can claim you honestly believe
your lies, but they still become ignorant pathological lies.

On 3/2/2024 6:47 PM, Richard Damon wrote:
> On 3/2/24 6:01 PM, olcott wrote:
>> On 3/2/2024 4:54 PM, Richard Damon wrote:
>>> On 3/2/24 5:28 PM, olcott wrote:
>>>> The reason that people assume that H1(D,D) must get
>>>> the same result as H(D,D) is that they make sure
>>>> to ignore the reason why they get a different result.
>>>
>>> Namely that you are lying that H and H1 are actually the same
>>> computation.
>>>
>>>>
>>>> It turns out that the only reason that H1(D,D) derives a
>>>> different result than H(D,D) is that H is at a different
>>>> physical machine address than H1.
>>>
>>> Which means that H and H1 are not computations, and you have been
>>> just an ignorant pathological liar all this time.
>>>
>>>>
>>>> D calls 00001522 // machine address of H
>>>> thus D does call 00001422 // machine address of H1
>>>>
>>>> Since this <is> the empirically determined deciding
>>>> factor I don't think that it can be correctly ignored.
>>>
>>> Right, but since the algorithm for H/H1 uses the address of the
>>> decider, which isn't defined as an "input" to it, we see that you
>>> have been lying that this code is a computation. Likely because you
>>> have made yourself ignorant of what a computation actually is,
>>>
>>> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>>>
>>>>
>>>> Any physically implemented Turing machine must exist
>>>> at some physical memory location.
>>>
>>> Nope.
>> Any *physically implemented Turing machine*
>> *physically implemented Turing machine*
>> *physically implemented Turing machine*
>> *physically implemented Turing machine*
>> must exist at some physical memory location.
>>
>> Try and explain the details of how it can be otherwise.
>>
>
> And description of a Turing Machine (or a Computation) that needs to
> reference atributes of Modern Electronic Computers is just WRONG as they
> predate the development of such a thing.
>

Virtual Machines that are exactly Turing Machines
except for unlimited memory can and do exist.

They necessarily must be implemented in physical memory
and cannot possibly be implemented any other way.

TM, The Turing Machine Interpreter
David S. Woodruff
http://www2.lns.mit.edu/~dsw/turing/turing.html

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

The states of a Turing machine <are> essentially
memory locations.

They have a perfect analogue in finite state machines
that physically exist outside of mere human imagination.
An actual DFA never transitions to an imaginary location
in one's mind.

> A simple implementation of a Turing Machine that has nothing like a
> "Memory Address" is a "Code Book", with the code for the Turing machine
> divided into logical "pages", each with the instructions for one state
> of the machine.
>
> On each page is a listing for each input that could be on the tape, the
> operation to do with the tape, including what symbol to write on the
> current location of the tape, and what the next state to go to.
>
> You then have a physical tape to write the symbols of tape, with
> something to indicate the current position we are on the tape.
>
> Thus starting on "page 0" (or whatever the starting state is) and
> procesing the tape as instructed, and turning the pages as instructed,
> you can run the Turing Machine to its final answer.
>
> (If you want to claim the page number represents a Memory Address, then
> you lose the fact that two different Turing Machine instances will have
> different "Memory Addresse"
>
>
> Remember, Turing Machines are not defined to be an "efficient" methods
> of computation, but are a tool to determine WHAT CAN be computed. This
> is primarily a MATHEMATICAL question, not a computerish question.
>
> Computation Theory is part of Computer Science, not because it tells us
> a lot about what Modern Computers can do, but out of the historical
> background and the foundations it lays.
>
>

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/2024 6:53 PM, Richard Damon wrote:
> On 3/2/24 7:26 PM, olcott wrote:
>> On 3/2/2024 4:54 PM, Richard Damon wrote:
>>> On 3/2/24 5:28 PM, olcott wrote:
>>>> The reason that people assume that H1(D,D) must get
>>>> the same result as H(D,D) is that they make sure
>>>> to ignore the reason why they get a different result.
>>>
>>> Namely that you are lying that H and H1 are actually the same
>>> computation.
>>>
>>>>
>>>> It turns out that the only reason that H1(D,D) derives a
>>>> different result than H(D,D) is that H is at a different
>>>> physical machine address than H1.
>>>
>>> Which means that H and H1 are not computations, and you have been
>>> just an ignorant pathological liar all this time.
>>>
>>>>
>>>> D calls 00001522 // machine address of H
>>>> thus D does call 00001422 // machine address of H1
>>>>
>>>> Since this <is> the empirically determined deciding
>>>> factor I don't think that it can be correctly ignored.
>>>
>>> Right, but since the algorithm for H/H1 uses the address of the
>>> decider, which isn't defined as an "input" to it, we see that you
>>> have been lying that this code is a computation. Likely because you
>>> have made yourself ignorant of what a computation actually is,
>>>
>>> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>>>
>>>>
>>>> Any physically implemented Turing machine must exist
>>>> at some physical memory location.
>>>
>>> Nope.
>>>
>>> Just proves you don't understand what a "Turing Machine" is.
>>>
>>>>
>>>> It is conventional to ignore this yet when it proves
>>>> to be the deciding factor then it is proven that it
>>>> cannot be correctly ignored.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> That means that any physically existing H is at a
>>>> different memory location than Ĥ.H.
>>>
>>> Ok, but it isn't allowed to use that address as part of its logic.
>>>
>>>>
>>>> We can imagine square roots of negative numbers.
>>>> What we cannot do is imagine them fitting coherently
>>>> into the rest of mathematics.
>>>
>>> Sure we can.
>>>
>>>>
>>>> I don't think that a machine architecture such that
>>>> every machine can always get its own machine address
>>>> breaks this.  https://en.wikipedia.org/wiki/Pure_function
>>>> *Someone on this forum agreed to that at some point*
>>>>
>>>
>>> it breaks the definition of a "Computation" if two supposed identical
>>> copies use it to act differently.
>>>
>>
>> If an otherwise identical machine is at a different physical
>> address and this difference by itself actually causes H/D
>> to have different behavior than H1/D then these machine
>> input pairs are not actually identical even when they have
>> identical bytes.
>>
>> Since we ourselves can see that H(D,D) would never stop
>> running unless aborted we ourselves can see the H must
>> abort its simulation to prevent its own non-termination.
>>
>> I think that it is an error to assume that computers are
>> theoretically strictly less powerful than human minds.
>>
>> I think that it is a big mistake to assume that computers
>> cannot see what we ourselves can clearly see.
>>
>
> If the machine is an actual computation, then its memory address does
> not affectd it.
>
> Your logic is just wrong.
>
> Note, Computers, as generally viewed, especiailly for "Compuation
> Theory" have the limitation of being deterministic, whcih DOES make them
> less powerful than the human mind, which has free will.

LLMs have contradicted that. They are inherently stochastic.

>
> Comuputers can only "See" what there programming has defined they are
> able to see.

LLMs have contradicted that. They have learned things
that their own developers do not understand how they
could have learned.

Free will aside there really is no actual reason why a
machine cannot possibly understand that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
simulated by Ĥ.H cannot possibly halt unless aborted.

When such a machine is programmed with the sum total
of current human knowledge it may even understand that
the best approach to convince you is to ridicule you
into submission (or not). It would totally understand
what ridicule is, how it works and the typical results
that ridicule achieves.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/2024 6:55 PM, Richard Damon wrote:
> On 3/2/24 6:25 PM, olcott wrote:
>> On 3/2/2024 5:15 PM, immibis wrote:
>>> On 2/03/24 23:28, olcott wrote:
>>>> The reason that people assume that H1(D,D) must get
>>>> the same result as H(D,D) is that they make sure
>>>> to ignore the reason why they get a different result.
>>>>
>>>> It turns out that the only reason that H1(D,D) derives a
>>>> different result than H(D,D) is that H is at a different
>>>> physical machine address than H1.
>>>
>>> Incorrect - the reason that H1(D,D) derives a different result is
>>> that H *looks for* a different physical machine address than H1.
>>
>> _D()
>> [00001cf2] 55         push ebp
>> [00001cf3] 8bec       mov ebp,esp
>> [00001cf5] 51         push ecx
>> [00001cf6] 8b4508     mov eax,[ebp+08]
>> [00001cf9] 50         push eax
>> [00001cfa] 8b4d08     mov ecx,[ebp+08]
>> [00001cfd] 51         push ecx
>> [00001cfe] e81ff8ffff call 00001522 ; call to H
>> ...
>>
>> *That is factually incorrect*
>> H and H1 simulate the actual code of D which actually
>> calls H at machine address 00001522 and does not call
>> H1 at machine address 00001422.
>
> Which proves that H and H1 are not the "Same Computation" (if they are
> computations at all)
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

Yet since we ourselves can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
simulated by Ĥ.H cannot possibly terminate unless
this simulation is aborted.

We ourselves can also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
does abort its simulation then Ĥ will halt.

I can't imagine that this will be forever too difficult
for a computer especially when ChatGPT 4.0 eventually
understood my critique the halting problem.
https://www.liarparadox.org/ChatGPT_HP.pdf

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/24 8:08 PM, olcott wrote:
> On 3/2/2024 6:47 PM, Richard Damon wrote:
>> On 3/2/24 6:01 PM, olcott wrote:
>>> On 3/2/2024 4:54 PM, Richard Damon wrote:
>>>> On 3/2/24 5:28 PM, olcott wrote:
>>>>> The reason that people assume that H1(D,D) must get
>>>>> the same result as H(D,D) is that they make sure
>>>>> to ignore the reason why they get a different result.
>>>>
>>>> Namely that you are lying that H and H1 are actually the same
>>>> computation.
>>>>
>>>>>
>>>>> It turns out that the only reason that H1(D,D) derives a
>>>>> different result than H(D,D) is that H is at a different
>>>>> physical machine address than H1.
>>>>
>>>> Which means that H and H1 are not computations, and you have been
>>>> just an ignorant pathological liar all this time.
>>>>
>>>>>
>>>>> D calls 00001522 // machine address of H
>>>>> thus D does call 00001422 // machine address of H1
>>>>>
>>>>> Since this <is> the empirically determined deciding
>>>>> factor I don't think that it can be correctly ignored.
>>>>
>>>> Right, but since the algorithm for H/H1 uses the address of the
>>>> decider, which isn't defined as an "input" to it, we see that you
>>>> have been lying that this code is a computation. Likely because you
>>>> have made yourself ignorant of what a computation actually is,
>>>>
>>>> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>>>>
>>>>>
>>>>> Any physically implemented Turing machine must exist
>>>>> at some physical memory location.
>>>>
>>>> Nope.
>>> Any *physically implemented Turing machine*
>>> *physically implemented Turing machine*
>>> *physically implemented Turing machine*
>>> *physically implemented Turing machine*
>>> must exist at some physical memory location.
>>>
>>> Try and explain the details of how it can be otherwise.
>>>
>>
>> And description of a Turing Machine (or a Computation) that needs to
>> reference atributes of Modern Electronic Computers is just WRONG as
>> they predate the development of such a thing.
>>
>
> Virtual Machines that are exactly Turing Machines
> except for unlimited memory can and do exist.
>
> They necessarily must be implemented in physical memory
> and cannot possibly be implemented any other way.

So?

Doesn't let a "Computation" change its answer based on its memory address.

You are just

>
> TM, The Turing Machine Interpreter
> David S. Woodruff
> http://www2.lns.mit.edu/~dsw/turing/turing.html
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> The states of a Turing machine <are> essentially
> memory locations.

Nope.

You proving your stupidity.

>
> They have a perfect analogue in finite state machines
> that physically exist outside of mere human imagination.
> An actual DFA never transitions to an imaginary location
> in one's mind.

Right, then transfer to the DEFINED state, that might be in ones mind if
the machine was just there.

>
>> A simple implementation of a Turing Machine that has nothing like a
>> "Memory Address" is a "Code Book", with the code for the Turing
>> machine divided into logical "pages", each with the instructions for
>> one state of the machine.
>>
>> On each page is a listing for each input that could be on the tape,
>> the operation to do with the tape, including what symbol to write on
>> the current location of the tape, and what the next state to go to.
>>
>> You then have a physical tape to write the symbols of tape, with
>> something to indicate the current position we are on the tape.
>>
>> Thus starting on "page 0" (or whatever the starting state is) and
>> procesing the tape as instructed, and turning the pages as instructed,
>> you can run the Turing Machine to its final answer.
>>
>> (If you want to claim the page number represents a Memory Address,
>> then you lose the fact that two different Turing Machine instances
>> will have different "Memory Addresse"
>>
>>
>> Remember, Turing Machines are not defined to be an "efficient" methods
>> of computation, but are a tool to determine WHAT CAN be computed. This
>> is primarily a MATHEMATICAL question, not a computerish question.
>>
>> Computation Theory is part of Computer Science, not because it tells
>> us a lot about what Modern Computers can do, but out of the historical
>> background and the foundations it lays.
>>
>>
>

All you are doing is proving that you are just LYING THROUGH YOUR TEETH
because you have no idea how things actually work.

You work has been proved to be a SHAM based on your ignorant
pathological lies.

You name may be remembered as the village idiot of computation theory.

On 3/2/2024 7:30 PM, Richard Damon wrote:
> On 3/2/24 8:08 PM, olcott wrote:
>> On 3/2/2024 6:47 PM, Richard Damon wrote:
>>> On 3/2/24 6:01 PM, olcott wrote:
>>>> On 3/2/2024 4:54 PM, Richard Damon wrote:
>>>>> On 3/2/24 5:28 PM, olcott wrote:
>>>>>> The reason that people assume that H1(D,D) must get
>>>>>> the same result as H(D,D) is that they make sure
>>>>>> to ignore the reason why they get a different result.
>>>>>
>>>>> Namely that you are lying that H and H1 are actually the same
>>>>> computation.
>>>>>
>>>>>>
>>>>>> It turns out that the only reason that H1(D,D) derives a
>>>>>> different result than H(D,D) is that H is at a different
>>>>>> physical machine address than H1.
>>>>>
>>>>> Which means that H and H1 are not computations, and you have been
>>>>> just an ignorant pathological liar all this time.
>>>>>
>>>>>>
>>>>>> D calls 00001522 // machine address of H
>>>>>> thus D does call 00001422 // machine address of H1
>>>>>>
>>>>>> Since this <is> the empirically determined deciding
>>>>>> factor I don't think that it can be correctly ignored.
>>>>>
>>>>> Right, but since the algorithm for H/H1 uses the address of the
>>>>> decider, which isn't defined as an "input" to it, we see that you
>>>>> have been lying that this code is a computation. Likely because you
>>>>> have made yourself ignorant of what a computation actually is,
>>>>>
>>>>> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>>>>>
>>>>>>
>>>>>> Any physically implemented Turing machine must exist
>>>>>> at some physical memory location.
>>>>>
>>>>> Nope.
>>>> Any *physically implemented Turing machine*
>>>> *physically implemented Turing machine*
>>>> *physically implemented Turing machine*
>>>> *physically implemented Turing machine*
>>>> must exist at some physical memory location.
>>>>
>>>> Try and explain the details of how it can be otherwise.
>>>>
>>>
>>> And description of a Turing Machine (or a Computation) that needs to
>>> reference atributes of Modern Electronic Computers is just WRONG as
>>> they predate the development of such a thing.
>>>
>>
>> Virtual Machines that are exactly Turing Machines
>> except for unlimited memory can and do exist.
>>
>> They necessarily must be implemented in physical memory
>> and cannot possibly be implemented any other way.
>
> So?
>
> Doesn't let a "Computation" change its answer based on its memory address.
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

We ourselves can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by
Ĥ.H cannot possibly terminate unless Ĥ.H aborts its
simulation.

We ourselves can also see that when Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
does abort its simulation then Ĥ will halt.

That no computer will ever achieve this degree of
understanding is directly contradicted by this:

ChatGPT 4.0 dialogue.
https://www.liarparadox.org/ChatGPT_HP.pdf

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/24 8:17 PM, olcott wrote:
> On 3/2/2024 6:53 PM, Richard Damon wrote:
>> On 3/2/24 7:26 PM, olcott wrote:
>>> On 3/2/2024 4:54 PM, Richard Damon wrote:
>>>> On 3/2/24 5:28 PM, olcott wrote:
>>>>> The reason that people assume that H1(D,D) must get
>>>>> the same result as H(D,D) is that they make sure
>>>>> to ignore the reason why they get a different result.
>>>>
>>>> Namely that you are lying that H and H1 are actually the same
>>>> computation.
>>>>
>>>>>
>>>>> It turns out that the only reason that H1(D,D) derives a
>>>>> different result than H(D,D) is that H is at a different
>>>>> physical machine address than H1.
>>>>
>>>> Which means that H and H1 are not computations, and you have been
>>>> just an ignorant pathological liar all this time.
>>>>
>>>>>
>>>>> D calls 00001522 // machine address of H
>>>>> thus D does call 00001422 // machine address of H1
>>>>>
>>>>> Since this <is> the empirically determined deciding
>>>>> factor I don't think that it can be correctly ignored.
>>>>
>>>> Right, but since the algorithm for H/H1 uses the address of the
>>>> decider, which isn't defined as an "input" to it, we see that you
>>>> have been lying that this code is a computation. Likely because you
>>>> have made yourself ignorant of what a computation actually is,
>>>>
>>>> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>>>>
>>>>>
>>>>> Any physically implemented Turing machine must exist
>>>>> at some physical memory location.
>>>>
>>>> Nope.
>>>>
>>>> Just proves you don't understand what a "Turing Machine" is.
>>>>
>>>>>
>>>>> It is conventional to ignore this yet when it proves
>>>>> to be the deciding factor then it is proven that it
>>>>> cannot be correctly ignored.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> That means that any physically existing H is at a
>>>>> different memory location than Ĥ.H.
>>>>
>>>> Ok, but it isn't allowed to use that address as part of its logic.
>>>>
>>>>>
>>>>> We can imagine square roots of negative numbers.
>>>>> What we cannot do is imagine them fitting coherently
>>>>> into the rest of mathematics.
>>>>
>>>> Sure we can.
>>>>
>>>>>
>>>>> I don't think that a machine architecture such that
>>>>> every machine can always get its own machine address
>>>>> breaks this.  https://en.wikipedia.org/wiki/Pure_function
>>>>> *Someone on this forum agreed to that at some point*
>>>>>
>>>>
>>>> it breaks the definition of a "Computation" if two supposed
>>>> identical copies use it to act differently.
>>>>
>>>
>>> If an otherwise identical machine is at a different physical
>>> address and this difference by itself actually causes H/D
>>> to have different behavior than H1/D then these machine
>>> input pairs are not actually identical even when they have
>>> identical bytes.
>>>
>>> Since we ourselves can see that H(D,D) would never stop
>>> running unless aborted we ourselves can see the H must
>>> abort its simulation to prevent its own non-termination.
>>>
>>> I think that it is an error to assume that computers are
>>> theoretically strictly less powerful than human minds.
>>>
>>> I think that it is a big mistake to assume that computers
>>> cannot see what we ourselves can clearly see.
>>>
>>
>> If the machine is an actual computation, then its memory address does
>> not affectd it.
>>
>> Your logic is just wrong.
>>
>> Note, Computers, as generally viewed, especiailly for "Compuation
>> Theory" have the limitation of being deterministic, whcih DOES make
>> them less powerful than the human mind, which has free will.
>
> LLMs have contradicted that. They are inherently stochastic.

Nope.

Sometime we intentionally add randomness into themm FOR TRAINING, but
there is nothing "inherent stochasitic"

>
>>
>> Comuputers can only "See" what there programming has defined they are
>> able to see.
>
> LLMs have contradicted that. They have learned things
> that their own developers do not understand how they
> could have learned.

Does't contradict what I said.

They only learned things within the bounds that the programming they
were given allowed.

Yes, having very fast operations and lots of memory, they can come up
with ideas we didn't think they would, and may not understand the
"reasoning" they used for it. It also means that they have logic bugs
that we may not be able to find.

For instance, ask a ChatGPT based system about SolidGoldMagikarp, (a
hard learned error due to the method of training).

LLM doesn't actually "Know" anything, It just has the ability to put
together a chain of words that sound realistic.

They will gladly give you false data if that seems most appropriate (and
Lawyers have gotten into trouble using some of their advice)

>
> Free will aside there really is no actual reason why a
> machine cannot possibly understand that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
> simulated by Ĥ.H cannot possibly halt unless aborted.

So, DID You sell your soul and your free will to the devil?

Free Will is an essentail part of Human Nature (and the logic about
personal choice).

>
> When such a machine is programmed with the sum total
> of current human knowledge it may even understand that
> the best approach to convince you is to ridicule you
> into submission (or not). It would totally understand
> what ridicule is, how it works and the typical results
> that ridicule achieves.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
>

Nope.

As I said, they don't actually "Know" anything, just that some words
work togther well to make what sounds like a reasonable answer.

On 3/2/24 8:29 PM, olcott wrote:
> On 3/2/2024 6:55 PM, Richard Damon wrote:
>> On 3/2/24 6:25 PM, olcott wrote:
>>> On 3/2/2024 5:15 PM, immibis wrote:
>>>> On 2/03/24 23:28, olcott wrote:
>>>>> The reason that people assume that H1(D,D) must get
>>>>> the same result as H(D,D) is that they make sure
>>>>> to ignore the reason why they get a different result.
>>>>>
>>>>> It turns out that the only reason that H1(D,D) derives a
>>>>> different result than H(D,D) is that H is at a different
>>>>> physical machine address than H1.
>>>>
>>>> Incorrect - the reason that H1(D,D) derives a different result is
>>>> that H *looks for* a different physical machine address than H1.
>>>
>>> _D()
>>> [00001cf2] 55         push ebp
>>> [00001cf3] 8bec       mov ebp,esp
>>> [00001cf5] 51         push ecx
>>> [00001cf6] 8b4508     mov eax,[ebp+08]
>>> [00001cf9] 50         push eax
>>> [00001cfa] 8b4d08     mov ecx,[ebp+08]
>>> [00001cfd] 51         push ecx
>>> [00001cfe] e81ff8ffff call 00001522 ; call to H
>>> ...
>>>
>>> *That is factually incorrect*
>>> H and H1 simulate the actual code of D which actually
>>> calls H at machine address 00001522 and does not call
>>> H1 at machine address 00001422.
>>
>> Which proves that H and H1 are not the "Same Computation" (if they are
>> computations at all)
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Yet since we ourselves can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
> simulated by Ĥ.H cannot possibly terminate unless
> this simulation is aborted.
>
> We ourselves can also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> does abort its simulation then Ĥ will halt.
>
> I can't imagine that this will be forever too difficult
> for a computer especially when ChatGPT 4.0 eventually
> understood my critique the halting problem.
> https://www.liarparadox.org/ChatGPT_HP.pdf
>
>

Because WE are not computations.

You are just proving that you are just a pathetic ignorant pathological
lying idiot.

On 3/2/24 8:38 PM, olcott wrote:
> On 3/2/2024 7:30 PM, Richard Damon wrote:
>> On 3/2/24 8:08 PM, olcott wrote:
>>> On 3/2/2024 6:47 PM, Richard Damon wrote:
>>>> On 3/2/24 6:01 PM, olcott wrote:
>>>>> On 3/2/2024 4:54 PM, Richard Damon wrote:
>>>>>> On 3/2/24 5:28 PM, olcott wrote:
>>>>>>> The reason that people assume that H1(D,D) must get
>>>>>>> the same result as H(D,D) is that they make sure
>>>>>>> to ignore the reason why they get a different result.
>>>>>>
>>>>>> Namely that you are lying that H and H1 are actually the same
>>>>>> computation.
>>>>>>
>>>>>>>
>>>>>>> It turns out that the only reason that H1(D,D) derives a
>>>>>>> different result than H(D,D) is that H is at a different
>>>>>>> physical machine address than H1.
>>>>>>
>>>>>> Which means that H and H1 are not computations, and you have been
>>>>>> just an ignorant pathological liar all this time.
>>>>>>
>>>>>>>
>>>>>>> D calls 00001522 // machine address of H
>>>>>>> thus D does call 00001422 // machine address of H1
>>>>>>>
>>>>>>> Since this <is> the empirically determined deciding
>>>>>>> factor I don't think that it can be correctly ignored.
>>>>>>
>>>>>> Right, but since the algorithm for H/H1 uses the address of the
>>>>>> decider, which isn't defined as an "input" to it, we see that you
>>>>>> have been lying that this code is a computation. Likely because
>>>>>> you have made yourself ignorant of what a computation actually is,
>>>>>>
>>>>>> Thus you have made yourself into an Ignorant Pathological Lying
>>>>>> Idiot.
>>>>>>
>>>>>>>
>>>>>>> Any physically implemented Turing machine must exist
>>>>>>> at some physical memory location.
>>>>>>
>>>>>> Nope.
>>>>> Any *physically implemented Turing machine*
>>>>> *physically implemented Turing machine*
>>>>> *physically implemented Turing machine*
>>>>> *physically implemented Turing machine*
>>>>> must exist at some physical memory location.
>>>>>
>>>>> Try and explain the details of how it can be otherwise.
>>>>>
>>>>
>>>> And description of a Turing Machine (or a Computation) that needs to
>>>> reference atributes of Modern Electronic Computers is just WRONG as
>>>> they predate the development of such a thing.
>>>>
>>>
>>> Virtual Machines that are exactly Turing Machines
>>> except for unlimited memory can and do exist.
>>>
>>> They necessarily must be implemented in physical memory
>>> and cannot possibly be implemented any other way.
>>
>> So?
>>
>> Doesn't let a "Computation" change its answer based on its memory
>> address.
>>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> We ourselves can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by
> Ĥ.H cannot possibly terminate unless Ĥ.H aborts its
> simulation.
>
> We ourselves can also see that when Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> does abort its simulation then Ĥ will halt.
>
> That no computer will ever achieve this degree of
> understanding is directly contradicted by this:
>
> ChatGPT 4.0 dialogue.
> https://www.liarparadox.org/ChatGPT_HP.pdf
>
>

No COMPUTATION can solve it, because it has been proved impossible.

Since a computer not doing a compuation doesn't qualify as a Halt
Decider, no computer will every be able to solve the problem within the
bounds of the problem.

You are just proving your are a pathetic ignorant pathological lying idiot.

Note, ChatGPT has been proven to LIE, so you can't trust what it says.

On 3/2/2024 7:41 PM, Richard Damon wrote:
> On 3/2/24 8:17 PM, olcott wrote:
>> On 3/2/2024 6:53 PM, Richard Damon wrote:
>>> On 3/2/24 7:26 PM, olcott wrote:
>>>> On 3/2/2024 4:54 PM, Richard Damon wrote:
>>>>> On 3/2/24 5:28 PM, olcott wrote:
>>>>>> The reason that people assume that H1(D,D) must get
>>>>>> the same result as H(D,D) is that they make sure
>>>>>> to ignore the reason why they get a different result.
>>>>>
>>>>> Namely that you are lying that H and H1 are actually the same
>>>>> computation.
>>>>>
>>>>>>
>>>>>> It turns out that the only reason that H1(D,D) derives a
>>>>>> different result than H(D,D) is that H is at a different
>>>>>> physical machine address than H1.
>>>>>
>>>>> Which means that H and H1 are not computations, and you have been
>>>>> just an ignorant pathological liar all this time.
>>>>>
>>>>>>
>>>>>> D calls 00001522 // machine address of H
>>>>>> thus D does call 00001422 // machine address of H1
>>>>>>
>>>>>> Since this <is> the empirically determined deciding
>>>>>> factor I don't think that it can be correctly ignored.
>>>>>
>>>>> Right, but since the algorithm for H/H1 uses the address of the
>>>>> decider, which isn't defined as an "input" to it, we see that you
>>>>> have been lying that this code is a computation. Likely because you
>>>>> have made yourself ignorant of what a computation actually is,
>>>>>
>>>>> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>>>>>
>>>>>>
>>>>>> Any physically implemented Turing machine must exist
>>>>>> at some physical memory location.
>>>>>
>>>>> Nope.
>>>>>
>>>>> Just proves you don't understand what a "Turing Machine" is.
>>>>>
>>>>>>
>>>>>> It is conventional to ignore this yet when it proves
>>>>>> to be the deciding factor then it is proven that it
>>>>>> cannot be correctly ignored.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> That means that any physically existing H is at a
>>>>>> different memory location than Ĥ.H.
>>>>>
>>>>> Ok, but it isn't allowed to use that address as part of its logic.
>>>>>
>>>>>>
>>>>>> We can imagine square roots of negative numbers.
>>>>>> What we cannot do is imagine them fitting coherently
>>>>>> into the rest of mathematics.
>>>>>
>>>>> Sure we can.
>>>>>
>>>>>>
>>>>>> I don't think that a machine architecture such that
>>>>>> every machine can always get its own machine address
>>>>>> breaks this.  https://en.wikipedia.org/wiki/Pure_function
>>>>>> *Someone on this forum agreed to that at some point*
>>>>>>
>>>>>
>>>>> it breaks the definition of a "Computation" if two supposed
>>>>> identical copies use it to act differently.
>>>>>
>>>>
>>>> If an otherwise identical machine is at a different physical
>>>> address and this difference by itself actually causes H/D
>>>> to have different behavior than H1/D then these machine
>>>> input pairs are not actually identical even when they have
>>>> identical bytes.
>>>>
>>>> Since we ourselves can see that H(D,D) would never stop
>>>> running unless aborted we ourselves can see the H must
>>>> abort its simulation to prevent its own non-termination.
>>>>
>>>> I think that it is an error to assume that computers are
>>>> theoretically strictly less powerful than human minds.
>>>>
>>>> I think that it is a big mistake to assume that computers
>>>> cannot see what we ourselves can clearly see.
>>>>
>>>
>>> If the machine is an actual computation, then its memory address does
>>> not affectd it.
>>>
>>> Your logic is just wrong.
>>>
>>> Note, Computers, as generally viewed, especiailly for "Compuation
>>> Theory" have the limitation of being deterministic, whcih DOES make
>>> them less powerful than the human mind, which has free will.
>>
>> LLMs have contradicted that. They are inherently stochastic.
>
> Nope.
>
> Sometime we intentionally add randomness into themm FOR TRAINING, but
> there is nothing "inherent stochasitic"
>
>>
>>>
>>> Comuputers can only "See" what there programming has defined they are
>>> able to see.
>>
>> LLMs have contradicted that. They have learned things
>> that their own developers do not understand how they
>> could have learned.
>
> Does't contradict what I said.
>
> They only learned things within the bounds that the programming they
> were given allowed.
>
> Yes, having very fast operations and lots of memory, they can come up
> with ideas we didn't think they would, and may not understand the
> "reasoning" they used for it. It also means that they have logic bugs
> that we may not be able to find.
>
> For instance, ask a ChatGPT based system about SolidGoldMagikarp, (a
> hard learned error due to the method of training).
>
> LLM doesn't actually "Know" anything, It just has the ability to put
> together a chain of words that sound realistic.
>
> They will gladly give you false data if that seems most appropriate (and
> Lawyers have gotten into trouble using some of their advice)
>
>>
>> Free will aside there really is no actual reason why a
>> machine cannot possibly understand that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
>> simulated by Ĥ.H cannot possibly halt unless aborted.
>
> So, DID You sell your soul and your free will to the devil?
>
> Free Will is an essentail part of Human Nature (and the logic about
> personal choice).
>
>>
>> When such a machine is programmed with the sum total
>> of current human knowledge it may even understand that
>> the best approach to convince you is to ridicule you
>> into submission (or not). It would totally understand
>> what ridicule is, how it works and the typical results
>> that ridicule achieves.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>>
>
> Nope.
>
> As I said, they don't actually "Know" anything, just that some words
> work togther well to make what sounds like a reasonable answer.

An LLM determines what the most probable next text will be.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/24 8:51 PM, olcott wrote:
> On 3/2/2024 7:41 PM, Richard Damon wrote:

>> As I said, they don't actually "Know" anything, just that some words
>> work togther well to make what sounds like a reasonable answer.
>
> An LLM determines what the most probable next text will be.
>

Which has NOTHING to do with "KNOWLEDGE"

The most likely word sequence is not base on what is "True" but base on
the learning samples, done with ZERO understanding of the semantics of
the data, what seemt the most likely sequence.

You are just proving that you are an ignorant pathological liar.

On 3/2/2024 7:43 PM, Richard Damon wrote:
> On 3/2/24 8:29 PM, olcott wrote:
>> On 3/2/2024 6:55 PM, Richard Damon wrote:
>>> On 3/2/24 6:25 PM, olcott wrote:
>>>> On 3/2/2024 5:15 PM, immibis wrote:
>>>>> On 2/03/24 23:28, olcott wrote:
>>>>>> The reason that people assume that H1(D,D) must get
>>>>>> the same result as H(D,D) is that they make sure
>>>>>> to ignore the reason why they get a different result.
>>>>>>
>>>>>> It turns out that the only reason that H1(D,D) derives a
>>>>>> different result than H(D,D) is that H is at a different
>>>>>> physical machine address than H1.
>>>>>
>>>>> Incorrect - the reason that H1(D,D) derives a different result is
>>>>> that H *looks for* a different physical machine address than H1.
>>>>
>>>> _D()
>>>> [00001cf2] 55         push ebp
>>>> [00001cf3] 8bec       mov ebp,esp
>>>> [00001cf5] 51         push ecx
>>>> [00001cf6] 8b4508     mov eax,[ebp+08]
>>>> [00001cf9] 50         push eax
>>>> [00001cfa] 8b4d08     mov ecx,[ebp+08]
>>>> [00001cfd] 51         push ecx
>>>> [00001cfe] e81ff8ffff call 00001522 ; call to H
>>>> ...
>>>>
>>>> *That is factually incorrect*
>>>> H and H1 simulate the actual code of D which actually
>>>> calls H at machine address 00001522 and does not call
>>>> H1 at machine address 00001422.
>>>
>>> Which proves that H and H1 are not the "Same Computation" (if they
>>> are computations at all)
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Yet since we ourselves can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
>> simulated by Ĥ.H cannot possibly terminate unless
>> this simulation is aborted.
>>
>> We ourselves can also see that Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>> does abort its simulation then Ĥ will halt.
>>
>> I can't imagine that this will be forever too difficult
>> for a computer especially when ChatGPT 4.0 eventually
>> understood my critique the halting problem.
>> https://www.liarparadox.org/ChatGPT_HP.pdf
>>
>>
>
> Because WE are not computations.
>
> You are just proving that you are just a pathetic ignorant pathological
> lying idiot.

Even though no LLM has any actual understanding
it did demonstrate the functional equivalent of
very deep understanding much more than any human
has ever demonstrated on the reasoning behind my
inferences.

I found that the entire original dialogue is still
there. It is named Paradoxical Yes_No Dilemma.
https://chat.openai.com/share/5607ac4d-2973-49f4-a335-31783bae899b

No PhD professors specializing in the these things
ever demonstrated the same depth of understanding
in any of their papers.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/2024 7:46 PM, Richard Damon wrote:
> On 3/2/24 8:38 PM, olcott wrote:
>> On 3/2/2024 7:30 PM, Richard Damon wrote:
>>> On 3/2/24 8:08 PM, olcott wrote:
>>>> On 3/2/2024 6:47 PM, Richard Damon wrote:
>>>>> On 3/2/24 6:01 PM, olcott wrote:
>>>>>> On 3/2/2024 4:54 PM, Richard Damon wrote:
>>>>>>> On 3/2/24 5:28 PM, olcott wrote:
>>>>>>>> The reason that people assume that H1(D,D) must get
>>>>>>>> the same result as H(D,D) is that they make sure
>>>>>>>> to ignore the reason why they get a different result.
>>>>>>>
>>>>>>> Namely that you are lying that H and H1 are actually the same
>>>>>>> computation.
>>>>>>>
>>>>>>>>
>>>>>>>> It turns out that the only reason that H1(D,D) derives a
>>>>>>>> different result than H(D,D) is that H is at a different
>>>>>>>> physical machine address than H1.
>>>>>>>
>>>>>>> Which means that H and H1 are not computations, and you have been
>>>>>>> just an ignorant pathological liar all this time.
>>>>>>>
>>>>>>>>
>>>>>>>> D calls 00001522 // machine address of H
>>>>>>>> thus D does call 00001422 // machine address of H1
>>>>>>>>
>>>>>>>> Since this <is> the empirically determined deciding
>>>>>>>> factor I don't think that it can be correctly ignored.
>>>>>>>
>>>>>>> Right, but since the algorithm for H/H1 uses the address of the
>>>>>>> decider, which isn't defined as an "input" to it, we see that you
>>>>>>> have been lying that this code is a computation. Likely because
>>>>>>> you have made yourself ignorant of what a computation actually is,
>>>>>>>
>>>>>>> Thus you have made yourself into an Ignorant Pathological Lying
>>>>>>> Idiot.
>>>>>>>
>>>>>>>>
>>>>>>>> Any physically implemented Turing machine must exist
>>>>>>>> at some physical memory location.
>>>>>>>
>>>>>>> Nope.
>>>>>> Any *physically implemented Turing machine*
>>>>>> *physically implemented Turing machine*
>>>>>> *physically implemented Turing machine*
>>>>>> *physically implemented Turing machine*
>>>>>> must exist at some physical memory location.
>>>>>>
>>>>>> Try and explain the details of how it can be otherwise.
>>>>>>
>>>>>
>>>>> And description of a Turing Machine (or a Computation) that needs
>>>>> to reference atributes of Modern Electronic Computers is just WRONG
>>>>> as they predate the development of such a thing.
>>>>>
>>>>
>>>> Virtual Machines that are exactly Turing Machines
>>>> except for unlimited memory can and do exist.
>>>>
>>>> They necessarily must be implemented in physical memory
>>>> and cannot possibly be implemented any other way.
>>>
>>> So?
>>>
>>> Doesn't let a "Computation" change its answer based on its memory
>>> address.
>>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> We ourselves can see that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by
>> Ĥ.H cannot possibly terminate unless Ĥ.H aborts its
>> simulation.
>>
>> We ourselves can also see that when Ĥ.H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>> does abort its simulation then Ĥ will halt.
>>
>> That no computer will ever achieve this degree of
>> understanding is directly contradicted by this:
>>
>> ChatGPT 4.0 dialogue.
>> https://www.liarparadox.org/ChatGPT_HP.pdf
>>
>>
>
> No COMPUTATION can solve it, because it has been proved impossible.

None-the-less actual computers do actually demonstrate
actual very deep understanding of these things.

This proves that the artifice of the human notion of
computation is more limiting than actual real computers.

It pretends to show the limits of what computers can do
yet is simply wrong about this.

> Note, ChatGPT has been proven to LIE, so you can't trust what it says.
That is why AI needs my formalization of the notion of
Boolean True(language L, Expression x).

The Cyc researchers proposed a solution similar to mine.
LLMs become anchored in knowledge ontologies so that they
can show the inference steps of their conclusion.

Getting from Generative AI to Trustworthy AI:
What LLMs might learn from Cyc
https://arxiv.org/abs/2308.04445

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/2/2024 7:57 PM, Richard Damon wrote:
> On 3/2/24 8:51 PM, olcott wrote:
>> On 3/2/2024 7:41 PM, Richard Damon wrote:
>
>>> As I said, they don't actually "Know" anything, just that some words
>>> work togther well to make what sounds like a reasonable answer.
>>
>> An LLM determines what the most probable next text will be.
>>
>
> Which has NOTHING to do with "KNOWLEDGE"
>
> The most likely word sequence is not base on what is "True" but base on
> the learning samples, done with ZERO understanding of the semantics of
> the data, what seemt the most likely sequence.

None-the-less it does demonstrate the functional equivalent of
deep understanding that has baffled its original developers.

>
> You are just proving that you are an ignorant pathological liar.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 2024-03-02 22:28:44 +0000, olcott said:

> The reason that people assume that H1(D,D) must get
> the same result as H(D,D) is that they make sure
> to ignore the reason why they get a different result.

It is quite obvious why H1 gets a different result from H.
It simply is that your "simulator" does not simulate
correctly. In spite of that, your H gets H(D,D) wrong,
so it is not a counter example to Linz' proof.

--
Mikko

On 2024-03-02 23:01:53 +0000, olcott said:

> On 3/2/2024 4:54 PM, Richard Damon wrote:
>> On 3/2/24 5:28 PM, olcott wrote:
>>> The reason that people assume that H1(D,D) must get
>>> the same result as H(D,D) is that they make sure
>>> to ignore the reason why they get a different result.
>>
>> Namely that you are lying that H and H1 are actually the same computation.
>>
>>>
>>> It turns out that the only reason that H1(D,D) derives a
>>> different result than H(D,D) is that H is at a different
>>> physical machine address than H1.
>>
>> Which means that H and H1 are not computations, and you have been just
>> an ignorant pathological liar all this time.
>>
>>>
>>> D calls 00001522 // machine address of H
>>> thus D does call 00001422 // machine address of H1
>>>
>>> Since this <is> the empirically determined deciding
>>> factor I don't think that it can be correctly ignored.
>>
>> Right, but since the algorithm for H/H1 uses the address of the
>> decider, which isn't defined as an "input" to it, we see that you have
>> been lying that this code is a computation. Likely because you have
>> made yourself ignorant of what a computation actually is,
>>
>> Thus you have made yourself into an Ignorant Pathological Lying Idiot.
>>
>>>
>>> Any physically implemented Turing machine must exist
>>> at some physical memory location.
>>
>> Nope.
> Any *physically implemented Turing machine*
> *physically implemented Turing machine*
> *physically implemented Turing machine*
> *physically implemented Turing machine*
> must exist at some physical memory location.
>
> Try and explain the details of how it can be otherwise.

Try to explain the detais how a machine made of Lego bricks
can be in a memory location.

--
Mikko