XPost: sci.logic

Op 03.jul.2024 om 20:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping [00002173] 8bec             mov ebp,esp   ; housekeeping [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD correctly emulated by any element of the infinite
set of every pure function HHH cannot possibly reach
its own ret instruction and halt. That HHH aborts its
emulation at some point or never aborts its emulation
cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.

It has been proved that HHH cannot possibly correctly simulate itself.
So, the above code shows that the incorrect simulation of DDD by HHH is
unable to reach the 'ret' instruction, because it either never aborts,
or aborts one cycle too soon, when the simulated HHH is only one cycle
from its own abort and return and then the return of DDD would follow.

Olcott could not find an error in this reasoning, but just repeats his
baseless claims. So, who is hiding the truth?

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 03.jul.2024 om 20:57 schreef olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping >>> [00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD correctly emulated by any element of the infinite
set of every pure function HHH cannot possibly reach
its own ret instruction and halt. That HHH aborts its
emulation at some point or never aborts its emulation
cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.

It has been proved that HHH cannot possibly correctly simulate itself.

That is false and you know it. That might not be a
flat out lie as it is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time,
then it stops correctly simulating itself because this criteria
is met:

    HHH correctly simulates its input DDD until HHH
    correctly determines that its simulated DDD would
    never stop running unless aborted

https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

So, the above code shows that the incorrect simulation of DDD by HHH
is unable to reach the 'ret' instruction, because it either never
aborts, or aborts one cycle too soon, when the simulated HHH is only
one cycle from its own abort and return and then the return of DDD
would follow.

The criteria is:
    HHH correctly simulates its input DDD until HHH
    correctly determines that its simulated DDD would
    never stop running unless aborted

It has been pointed out many times that this is sloppy use of language.
HHH *does* abort, so the 'unless aborted' does not make sense.
Since HHH *does* abort, its simulation does not need to be aborted (as a correct simulation by another simulator shows).
HHH is incorrect when it determines that the simulation of an aborting
self would never stop. If not aborted, the simulated HHH would abort,
because that is how it is programmed. But the simulating HHH does not
see that, because it aborts one cycle too soon.
The reason is that a simulator cannot possible correctly simulate itself.
I hope you finally see it.
The wording 'would never stop running unless aborted' suggests that
there is a possibility that the simulated HHH would not abort, but that
is just an irrelevant dream, because this HHH is programmed to abort and
there is no other HHH in this simulation.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 03.jul.2024 om 21:15 schreef olcott:

On 7/3/2024 2:11 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:57 schreef olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD correctly emulated by any element of the infinite
set of every pure function HHH cannot possibly reach
its own ret instruction and halt. That HHH aborts its
emulation at some point or never aborts its emulation
cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.

It has been proved that HHH cannot possibly correctly simulate itself.

That is false and you know it. That might not be a
flat out lie as it is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time,
then it stops correctly simulating itself because this criteria
is met:

     HHH correctly simulates its input DDD until HHH
     correctly determines that its simulated DDD would
     never stop running unless aborted

https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

So, the above code shows that the incorrect simulation of DDD by HHH
is unable to reach the 'ret' instruction, because it either never
aborts, or aborts one cycle too soon, when the simulated HHH is only
one cycle from its own abort and return and then the return of DDD
would follow.

The criteria is:
     HHH correctly simulates its input DDD until HHH
     correctly determines that its simulated DDD would
     never stop running unless aborted

It has been pointed out many times that this is sloppy use of language.

It is the case that DDD correctly simulated by HHH cannot
possibly reach its own ret instruction NO MATTER WHAT.

This proves that HHH is unable to simulate itself.
It also proves that the simulation is not correct, no matter how strong
your hope it is.

As soon as HHH sees this it is necessarily correct for HHH
to reject DDD as non-halting.

Which is incorrect. (And for an incorrect simulation, Sipser does not
apply.)
The problem is that when HHH aborts its simulation, the aborted HHH is
only one cycle away from its own abort operation, so that the first
abort was not required. (The abort is required only when simulating an
HHH that does not abort, but a HHH that does not abort is only an
irrelevant dream.) The simulating HHH misses the fact that the simulated
HHH would abort and return and then DDD would return.
Therefore, the conclusion non-halting is premature.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 03.jul.2024 om 22:04 schreef olcott:

On 7/3/2024 2:27 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 21:15 schreef olcott:

On 7/3/2024 2:11 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:57 schreef olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD correctly emulated by any element of the infinite
set of every pure function HHH cannot possibly reach
its own ret instruction and halt. That HHH aborts its
emulation at some point or never aborts its emulation
cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.

It has been proved that HHH cannot possibly correctly simulate
itself.

That is false and you know it. That might not be a
flat out lie as it is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time,
then it stops correctly simulating itself because this criteria
is met:

     HHH correctly simulates its input DDD until HHH
     correctly determines that its simulated DDD would
     never stop running unless aborted

https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

So, the above code shows that the incorrect simulation of DDD by
HHH is unable to reach the 'ret' instruction, because it either
never aborts, or aborts one cycle too soon, when the simulated HHH >>>>>> is only one cycle from its own abort and return and then the
return of DDD would follow.

The criteria is:
     HHH correctly simulates its input DDD until HHH
     correctly determines that its simulated DDD would
     never stop running unless aborted

It has been pointed out many times that this is sloppy use of language. >>>

It is the case that DDD correctly simulated by HHH cannot
possibly reach its own ret instruction NO MATTER WHAT.

This proves that HHH is unable to simulate itself.

How the Hell do you think that you can get away with
this when I proved that HHH does correctly emulate itself? https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

But you didn't simulate infinite behavior to the end.
Of course I didn't infinite behavior HAS NO END.

Why did do you ask such a strange question?
Your trace shows that you didn't simulate the *finite* behaviour to the
end. The simulation of the *finite* recursion was aborted one cycle too
soon. A *finite* behaviour HAS AN END.
There is no HHH that does not abort, so the simulation of HHH HAS AN END. Dreaming of an HHH that does not abort and has no end is irrelevant.
There is no such HHH.
So, your proof failed, because of the false assumption that the
simulation of HHH, which aborts, has no end.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-07-03 18:20:39 +0000, olcott said:

_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]

DDD correctly emulated by any element of the infinite
set of every pure function HHH cannot possibly reach
its own ret instruction and halt. That HHH aborts its
emulation at some point or never aborts its emulation
cannot possibly change this.

The function at 15d2 is a single specific function, not a specification
of a set of functions.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 03.jul.2024 om 23:02 schreef olcott:

On 7/3/2024 3:55 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 22:04 schreef olcott:

On 7/3/2024 2:27 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 21:15 schreef olcott:

On 7/3/2024 2:11 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:57 schreef olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD correctly emulated by any element of the infinite
set of every pure function HHH cannot possibly reach
its own ret instruction and halt. That HHH aborts its
emulation at some point or never aborts its emulation
cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation. >>>>>>>>
It has been proved that HHH cannot possibly correctly simulate >>>>>>>> itself.

That is false and you know it. That might not be a
flat out lie as it is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time,
then it stops correctly simulating itself because this criteria
is met:

     HHH correctly simulates its input DDD until HHH
     correctly determines that its simulated DDD would
     never stop running unless aborted

https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

So, the above code shows that the incorrect simulation of DDD by >>>>>>>> HHH is unable to reach the 'ret' instruction, because it either >>>>>>>> never aborts, or aborts one cycle too soon, when the simulated >>>>>>>> HHH is only one cycle from its own abort and return and then the >>>>>>>> return of DDD would follow.

The criteria is:
     HHH correctly simulates its input DDD until HHH
     correctly determines that its simulated DDD would
     never stop running unless aborted

It has been pointed out many times that this is sloppy use of
language.

It is the case that DDD correctly simulated by HHH cannot
possibly reach its own ret instruction NO MATTER WHAT.

This proves that HHH is unable to simulate itself.

How the Hell do you think that you can get away with
this when I proved that HHH does correctly emulate itself?
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

But you didn't simulate infinite behavior to the end.
Of course I didn't infinite behavior HAS NO END.

Why did do you ask such a strange question?
Your trace shows that you didn't simulate the *finite*

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

When DDD is correctly emulated by HHH neither the
emulated DDD nor the emulated HHH can possibly stop
running unless DDD is aborted.

*Endlessly repeats until aborted*
HHH emulates DDD that calls HHH(DDD)

No contribution to the discussion detected. Only a repetition of a false
claim and self-contradictory sentences.
"Endlessly repeats untill aborted." Make up your mind. Is is endless, or
is it aborted? An aborted simulation is not endless. In particular when
the simulation is aborted when it is only one cycle before its end.

I proved already HHH cannot possibly correctly simulate itself,
therefore the set of HHH that correctly simulate itself is empty.
Therefore, "When DDD correctly emulated by HHH ..." is referring to an
empty set of HHH, because DDD contains HHH.

Your infinite/endless recursion is your dream of an HHH that does not
abort, but that is irrelevant, since such an HHH is not in this program.
The HHH that is in this program is programmed to abort.
Just as Sipser agreed, only a correct simulation can show termination behaviour, not an incorrect simulation of a *finite* recursion based on
a dream of an infinite recursion.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 04.jul.2024 om 14:42 schreef olcott:

On 7/4/2024 2:45 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 23:02 schreef olcott:

On 7/3/2024 3:55 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 22:04 schreef olcott:

On 7/3/2024 2:27 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 21:15 schreef olcott:

On 7/3/2024 2:11 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:57 schreef olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD correctly emulated by any element of the infinite
set of every pure function HHH cannot possibly reach
its own ret instruction and halt. That HHH aborts its
emulation at some point or never aborts its emulation
cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation. >>>>>>>>>>
It has been proved that HHH cannot possibly correctly simulate >>>>>>>>>> itself.

That is false and you know it. That might not be a
flat out lie as it is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time,
then it stops correctly simulating itself because this criteria >>>>>>>>> is met:

     HHH correctly simulates its input DDD until HHH
     correctly determines that its simulated DDD would
     never stop running unless aborted

https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

So, the above code shows that the incorrect simulation of DDD >>>>>>>>>> by HHH is unable to reach the 'ret' instruction, because it >>>>>>>>>> either never aborts, or aborts one cycle too soon, when the >>>>>>>>>> simulated HHH is only one cycle from its own abort and return >>>>>>>>>> and then the return of DDD would follow.

The criteria is:
     HHH correctly simulates its input DDD until HHH
     correctly determines that its simulated DDD would
     never stop running unless aborted

It has been pointed out many times that this is sloppy use of
language.

It is the case that DDD correctly simulated by HHH cannot
possibly reach its own ret instruction NO MATTER WHAT.

This proves that HHH is unable to simulate itself.

How the Hell do you think that you can get away with
this when I proved that HHH does correctly emulate itself?
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

But you didn't simulate infinite behavior to the end.
Of course I didn't infinite behavior HAS NO END.

Why did do you ask such a strange question?
Your trace shows that you didn't simulate the *finite*

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

When DDD is correctly emulated by HHH neither the
emulated DDD nor the emulated HHH can possibly stop
running unless DDD is aborted.

*Endlessly repeats until aborted*
HHH emulates DDD that calls HHH(DDD)

No contribution to the discussion detected.

Liar

The ad hominem attack is probably meant to hide that you have no more argumentation.

I showed that HHH cannot possibly correctly simulate itself.
For HHH that does not abort, it is clear, because it would simulate
infinitely, but does not apply here, because we are talking about HHH
that *does* abort.
For HHH that aborts after N cycles, it is also true, because when the simulating HHH aborts, the simulated HHH has performed N-1 cycles and is
only one cycle from its own abort, after which it would return. A
correct simulation of HHH by another simulator demonstrates this. The simulating HHH misses this return and therefore the simulation is incorrect.

This reasoning is supported by the x86 code that olcott often posts
here, see above, where even he seems to understand that the simulating
HHH cannot reach the 'ret' of the simulated HHH.
This is supported in even more detail in his 'simulation trace', where
we also see that the simulating HHH aborts before the simulated HHH
reaches its abort and return.
Since the simulation is incorrect, also Sipser would agree that it is
not possible to conclude that there is a non-halting status.

Thanks to olcott for so many contributions to support this statement.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 04.jul.2024 om 21:30 schreef olcott:

On 7/4/2024 2:26 PM, Fred. Zwarts wrote:

Op 04.jul.2024 om 14:42 schreef olcott:

On 7/4/2024 2:45 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 23:02 schreef olcott:

On 7/3/2024 3:55 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 22:04 schreef olcott:

On 7/3/2024 2:27 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 21:15 schreef olcott:

On 7/3/2024 2:11 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:57 schreef olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD correctly emulated by any element of the infinite >>>>>>>>>>>>> set of every pure function HHH cannot possibly reach >>>>>>>>>>>>> its own ret instruction and halt. That HHH aborts its >>>>>>>>>>>>> emulation at some point or never aborts its emulation >>>>>>>>>>>>> cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation. >>>>>>>>>>>>
It has been proved that HHH cannot possibly correctly
simulate itself.

That is false and you know it. That might not be a
flat out lie as it is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, >>>>>>>>>>> then it stops correctly simulating itself because this criteria >>>>>>>>>>> is met:

     HHH correctly simulates its input DDD until HHH >>>>>>>>>>>      correctly determines that its simulated DDD would >>>>>>>>>>>      never stop running unless aborted

https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

So, the above code shows that the incorrect simulation of >>>>>>>>>>>> DDD by HHH is unable to reach the 'ret' instruction, because >>>>>>>>>>>> it either never aborts, or aborts one cycle too soon, when >>>>>>>>>>>> the simulated HHH is only one cycle from its own abort and >>>>>>>>>>>> return and then the return of DDD would follow.

The criteria is:
     HHH correctly simulates its input DDD until HHH >>>>>>>>>>>      correctly determines that its simulated DDD would >>>>>>>>>>>      never stop running unless aborted

It has been pointed out many times that this is sloppy use of >>>>>>>>>> language.

It is the case that DDD correctly simulated by HHH cannot
possibly reach its own ret instruction NO MATTER WHAT.

This proves that HHH is unable to simulate itself.

How the Hell do you think that you can get away with
this when I proved that HHH does correctly emulate itself?
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

But you didn't simulate infinite behavior to the end.
Of course I didn't infinite behavior HAS NO END.

Why did do you ask such a strange question?
Your trace shows that you didn't simulate the *finite*

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

When DDD is correctly emulated by HHH neither the
emulated DDD nor the emulated HHH can possibly stop
running unless DDD is aborted.

*Endlessly repeats until aborted*
HHH emulates DDD that calls HHH(DDD)

No contribution to the discussion detected.

Liar

The ad hominem attack is probably meant to hide that you have no more
argumentation.

I showed that HHH cannot possibly correctly simulate itself.

I proved otherwise, Liar.
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

No, this trace supports my claim. When we look at this trace we see that
the simulating HHH is unable to reach the 'ret' of the simulated HHH.
The simulating HHH aborts one cycle before the simulated HHH would abort
and return. The simulating HHH misses this last part of the simulation
and, therefore, the simulation is incorrect.
Thanks for the trace. It supports my claim.

For HHH that does not abort, it is clear, because it would simulate
infinitely, but does not apply here, because we are talking about HHH
that *does* abort.
For HHH that aborts after N cycles, it is also true, because when the
simulating HHH aborts, the simulated HHH has performed N-1 cycles and
is only one cycle from its own abort, after which it would return. A
correct simulation of HHH by another simulator demonstrates this. The
simulating HHH misses this return and therefore the simulation is
incorrect.

This reasoning is supported by the x86 code that olcott often posts
here, see above, where even he seems to understand that the simulating
HHH cannot reach the 'ret' of the simulated HHH.
This is supported in even more detail in his 'simulation trace', where
we also see that the simulating HHH aborts before the simulated HHH
reaches its abort and return.
Since the simulation is incorrect, also Sipser would agree that it is
not possible to conclude that there is a non-halting status.

Thanks to olcott for so many contributions to support this statement.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: sci.logic

Op 04.jul.2024 om 21:45 schreef olcott:

On 7/4/2024 2:40 PM, Fred. Zwarts wrote:

Op 04.jul.2024 om 21:30 schreef olcott:

On 7/4/2024 2:26 PM, Fred. Zwarts wrote:

Op 04.jul.2024 om 14:42 schreef olcott:

On 7/4/2024 2:45 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 23:02 schreef olcott:

On 7/3/2024 3:55 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 22:04 schreef olcott:

On 7/3/2024 2:27 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 21:15 schreef olcott:

On 7/3/2024 2:11 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:57 schreef olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>> [0000217f] 83c404           add esp,+04 >>>>>>>>>>>>>>> [00002182] 5d               pop ebp >>>>>>>>>>>>>>> [00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD correctly emulated by any element of the infinite >>>>>>>>>>>>>>> set of every pure function HHH cannot possibly reach >>>>>>>>>>>>>>> its own ret instruction and halt. That HHH aborts its >>>>>>>>>>>>>>> emulation at some point or never aborts its emulation >>>>>>>>>>>>>>> cannot possibly change this.

Ad hominem attacks always try to hide a lack of
argumentation.

It has been proved that HHH cannot possibly correctly >>>>>>>>>>>>>> simulate itself.

That is false and you know it. That might not be a
flat out lie as it is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, >>>>>>>>>>>>> then it stops correctly simulating itself because this >>>>>>>>>>>>> criteria
is met:

     HHH correctly simulates its input DDD until HHH >>>>>>>>>>>>>      correctly determines that its simulated DDD would >>>>>>>>>>>>>      never stop running unless aborted

https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

So, the above code shows that the incorrect simulation of >>>>>>>>>>>>>> DDD by HHH is unable to reach the 'ret' instruction, >>>>>>>>>>>>>> because it either never aborts, or aborts one cycle too >>>>>>>>>>>>>> soon, when the simulated HHH is only one cycle from its >>>>>>>>>>>>>> own abort and return and then the return of DDD would follow. >>>>>>>>>>>>>>

The criteria is:
     HHH correctly simulates its input DDD until HHH >>>>>>>>>>>>>      correctly determines that its simulated DDD would >>>>>>>>>>>>>      never stop running unless aborted

It has been pointed out many times that this is sloppy use >>>>>>>>>>>> of language.

It is the case that DDD correctly simulated by HHH cannot >>>>>>>>>>> possibly reach its own ret instruction NO MATTER WHAT.

This proves that HHH is unable to simulate itself.

How the Hell do you think that you can get away with
this when I proved that HHH does correctly emulate itself?
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

But you didn't simulate infinite behavior to the end.
Of course I didn't infinite behavior HAS NO END.

Why did do you ask such a strange question?
Your trace shows that you didn't simulate the *finite*

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

When DDD is correctly emulated by HHH neither the
emulated DDD nor the emulated HHH can possibly stop
running unless DDD is aborted.

*Endlessly repeats until aborted*
HHH emulates DDD that calls HHH(DDD)

No contribution to the discussion detected.

Liar

The ad hominem attack is probably meant to hide that you have no
more argumentation.

I showed that HHH cannot possibly correctly simulate itself.

I proved otherwise, Liar.
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

No, this trace supports my claim. When we look at this trace we see that

HHH is simulating itself simulating DDD until it sees
that DDD is calling HHH in recursive simulation such
that neither the simulated DDD nor the simulated HHH
can possibly stop running unless HHH aborts its DDD.

The 'unless HHH aborts ...' is irrelevant and misleading, because we
know HHH *does* aborts. Dreaming of an HHH that does not abort is
irrelevant.
HHH is programmed to abort, so it is nonsense that it cannot possibly
stop running. It is programmed to stop after N cycles of recursive
simulation by aborting its simulation.
An aborting simulator does not need to be aborted, not even when it is simulated.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

HHH is simulating itself. It sees a N nested recursions and aborts.
It does not see that one cycle later, the simulated HHH would also abort
and return. So, it misses an important part of the input, which makes
the simulation incorrect.

Your x86 code and your simulation trace is evidence that this is true
for people who understand x86 code. The simulating HHH cannot possible
reach the 'ret' of the simulated HHH. The x86 code when not aborted,
would reach the 'ret' of the simulated HHH.
Therefore, the simulation of HHH by itself cannot possibly be correct.

This may be you last chance before I ignore everything
that you say and write you off as a liar.

We know that you do not have the competence to recognize the truth, so I
do not feel offended.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every
pure function HHH cannot possibly reach its own ret instruction and
halt. That HHH aborts its emulation at some point or never aborts its
emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.
It has been proved that HHH cannot possibly correctly simulate itself.

That is false and you know it. That might not be a flat out lie as it is
an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it
stops correctly simulating itself because this criteria is met:
HHH correctly simulates its input DDD until HHH correctly
determines that its simulated DDD would never stop running unless
aborted

But it would stop running.

So, the above code shows that the incorrect simulation of DDD by HHH is
unable to reach the 'ret' instruction, because it either never aborts,
or aborts one cycle too soon, when the simulated HHH is only one cycle
from its own abort and return and then the return of DDD would follow.

The criteria is:
HHH simulates its input DDD until HHH
determines that its simulated DDD would never stop running unless
aborted
Richard always lies about this by making sure that he ever sees the word UNTIL.

--
Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
Objectively I am a genius.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 05.jul.2024 om 14:20 schreef olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every
pure function HHH cannot possibly reach its own ret instruction and
halt. That HHH aborts its emulation at some point or never aborts its >>>>> emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.
It has been proved that HHH cannot possibly correctly simulate itself.

That is false and you know it. That might not be a flat out lie as it is >>> an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it
stops correctly simulating itself because this criteria is met:
      HHH correctly simulates its input DDD until HHH correctly
      determines that its simulated DDD would never stop running unless
      aborted

But it would stop running.

Not if not aborted.

If you knew a little bit of programming, you would know that a program
that is programmed to abort and stop, will abort and stop, if not aborted. Dreaming of a program without abort is irrelevant, because HHH *does* abort.

So, the above code shows that the incorrect simulation of DDD by HHH is >>>> unable to reach the 'ret' instruction, because it either never aborts, >>>> or aborts one cycle too soon, when the simulated HHH is only one cycle >>>> from its own abort and return and then the return of DDD would follow.

The criteria is:
      HHH simulates its input DDD until HHH
      determines that its simulated DDD would never stop running unless
      aborted
Richard always lies about this by making sure that he ever sees the word >>> UNTIL.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Fri, 05 Jul 2024 07:20:04 -0500 schrieb olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every
pure function HHH cannot possibly reach its own ret instruction and
halt. That HHH aborts its emulation at some point or never aborts
its emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.
It has been proved that HHH cannot possibly correctly simulate
itself.

That is false and you know it. That might not be a flat out lie as it
is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it
stops correctly simulating itself because this criteria is met:
HHH correctly simulates its input DDD until HHH correctly
determines that its simulated DDD would never stop running
unless aborted

But it would stop running.

Not if not aborted.

But it is aborted!

--
Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
Objectively I am a genius.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 05.jul.2024 om 14:43 schreef olcott:

On 7/5/2024 7:26 AM, joes wrote:

Am Fri, 05 Jul 2024 07:20:04 -0500 schrieb olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every >>>>>>> pure function HHH cannot possibly reach its own ret instruction and >>>>>>> halt. That HHH aborts its emulation at some point or never aborts >>>>>>> its emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.
It has been proved that HHH cannot possibly correctly simulate
itself.

That is false and you know it. That might not be a flat out lie as it >>>>> is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it
stops correctly simulating itself because this criteria is met:
       HHH correctly simulates its input DDD until HHH correctly >>>>>        determines that its simulated DDD would never stop running >>>>>        unless aborted

But it would stop running.

Not if not aborted.

But it is aborted!

*It is not aborted when HHH makes its decision to abort*
It is a fact that HHH must abort the simulation of its
input to prevent its own infinite execution.

Incorrect! The input already aborts and halts, so the simulator does not
need to abort. However, HHH cannot possibly correctly simulate itself,
because it is programmed to abort prematurely.

At the point in the execution trace of DDD correctly
emulated by HHH where it knows that it must abort HHH
has correctly determined that DDD is non-halting.

It incorrectly did it. DDD is not non-halting, because DDD would return
if not aborted, because the HHH on which it is based would abort and
return. So, the simulator prematurely decided to abort and halt.

Every time that HHH must abort the emulation of ANY input
to prevent its own infinite execution HHH is always correct
to do this and reject this input as non-halting

But in this case there is no need to prevent an infinite recursion,
because the simulated HHH already aborts and halts, so, there is no
infinite recursion.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

There is only an infinite recursion when you are dreaming of an HHH that
does not abort, but such dreams are irrelevant, because the HHH we are
talking about, *does* abort.

The above is a tautology.

This tautology does not apply, because the assumptions are false.





--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

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

On 7/5/2024 7:29 AM, Fred. Zwarts wrote:

Op 05.jul.2024 om 14:20 schreef olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every >>>>>>> pure function HHH cannot possibly reach its own ret instruction and >>>>>>> halt. That HHH aborts its emulation at some point or never aborts >>>>>>> its
emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.
It has been proved that HHH cannot possibly correctly simulate
itself.

That is false and you know it. That might not be a flat out lie as
it is
an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it
stops correctly simulating itself because this criteria is met:
      HHH correctly simulates its input DDD until HHH correctly >>>>>       determines that its simulated DDD would never stop running >>>>> unless
      aborted

But it would stop running.

Not if not aborted.

If you knew a little bit of programming, you would know that a program
that is programmed to abort and stop, will abort and stop, if not
aborted.

I have two software engineering patents.
HHH is a generic program that works on many different
inputs thus it is not programmed to abort and stop.
It is programmed according to this algorithm.

Apparently the algorithm is incorrect, because it does not recognize
that the simulation of HHH would reach its end, if not aborted, because
the simulated HHH aborts and returns.
HHH cannot possibly correctly simulate itself.

Unless you think that the #1 best selling author of theory
of computation textbooks is wrong then I am correct.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

You keep repeating irrelevant texts. Sipser agreed to a correct
simulation, but I have shown that you simulation is incorrect.
HHH cannot possibly correctly simulate itself.
This is supported by your x86 code, for which you admit that the
simulation cannot possibly reach its own 'ret'. Therefore, it is unable
to fully process its input.
Additional evidence is in the trace you showed, where we see that,
indeed, the simulation does not reach the 'ret' of its simulated self,
but aborts prematurely.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

There is no need to abort this program, even after several recursions.

Dreaming of a program without abort is irrelevant, because HHH *does*
abort.

So, the above code shows that the incorrect simulation of DDD by
HHH is
unable to reach the 'ret' instruction, because it either never
aborts,
or aborts one cycle too soon, when the simulated HHH is only one
cycle
from its own abort and return and then the return of DDD would
follow.

The criteria is:
      HHH simulates its input DDD until HHH
      determines that its simulated DDD would never stop running >>>>> unless
      aborted
Richard always lies about this by making sure that he ever sees the
word
UNTIL.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/5/24 8:43 AM, olcott wrote:

On 7/5/2024 7:26 AM, joes wrote:

Am Fri, 05 Jul 2024 07:20:04 -0500 schrieb olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every >>>>>>> pure function HHH cannot possibly reach its own ret instruction and >>>>>>> halt. That HHH aborts its emulation at some point or never aborts >>>>>>> its emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.
It has been proved that HHH cannot possibly correctly simulate
itself.

That is false and you know it. That might not be a flat out lie as it >>>>> is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it
stops correctly simulating itself because this criteria is met:
       HHH correctly simulates its input DDD until HHH correctly >>>>>        determines that its simulated DDD would never stop running >>>>>        unless aborted

But it would stop running.

Not if not aborted.

But it is aborted!

*It is not aborted when HHH makes its decision to abort*
It is a fact that HHH must abort the simulation of its
input to prevent its own infinite execution.

And thus gets the wrong answer about the input.

HHH aborts ITS SIMULATION, not the behavior of the program represented
by the input.

At the point in the execution trace of DDD correctly
emulated by HHH where it knows that it must abort HHH
has correctly determined that DDD is non-halting.

Only in you broken logic, since it can be shown that DDD will halt.

Your problem is you lie to yourself that HHH did a correct emulation of
the input, it only did a PARTIAL emulation, so only determined PART of
the behavior and incorrectly extrapolated.

Every time that HHH must abort the emulation of ANY input
to prevent its own infinite execution HHH is always correct
to do this and reject this input as non-halting

The above is a tautology.

Nope, it is a LIE.

Something you are famous for doing.

Just like your claiming a Diagonalization proof that shows Godel wrong
existed, and then you said that all Diagonalizations proofs were nonsense.

All you idea are just nonsense (even if some individual statements might
have truth, by being mixed up in your nonsense, they become nonsense).




--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/5/24 9:04 AM, olcott wrote:

On 7/5/2024 7:29 AM, Fred. Zwarts wrote:

Op 05.jul.2024 om 14:20 schreef olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every >>>>>>> pure function HHH cannot possibly reach its own ret instruction and >>>>>>> halt. That HHH aborts its emulation at some point or never aborts >>>>>>> its
emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.
It has been proved that HHH cannot possibly correctly simulate
itself.

That is false and you know it. That might not be a flat out lie as
it is
an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it
stops correctly simulating itself because this criteria is met:
      HHH correctly simulates its input DDD until HHH correctly >>>>>       determines that its simulated DDD would never stop running >>>>> unless
      aborted

But it would stop running.

Not if not aborted.

If you knew a little bit of programming, you would know that a program
that is programmed to abort and stop, will abort and stop, if not
aborted.

I have two software engineering patents.
HHH is a generic program that works on many different
inputs thus it is not programmed to abort and stop.
It is programmed according to this algorithm.

Unless you think that the #1 best selling author of theory
of computation textbooks is wrong then I am correct.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Except he doesn't support you claim as you don't use the right
definition of "Correctly Simulate", which means the simulation that
exactly reproduces the behavior of the program represented by the input,
and thus one that doesn't abort it.

You H neither does that itself, or correctly predicts the behavior of
such a simulation of this exact input (which will still call this H), it
can't use that second paragraph to claim that its aborting was correct.

Dreaming of a program without abort is irrelevant, because HHH *does*
abort.

So, the above code shows that the incorrect simulation of DDD by
HHH is
unable to reach the 'ret' instruction, because it either never
aborts,
or aborts one cycle too soon, when the simulated HHH is only one
cycle
from its own abort and return and then the return of DDD would
follow.

The criteria is:
      HHH simulates its input DDD until HHH
      determines that its simulated DDD would never stop running >>>>> unless
      aborted
Richard always lies about this by making sure that he ever sees the
word
UNTIL.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/5/24 10:13 AM, olcott wrote:

On 7/5/2024 9:10 AM, Fred. Zwarts wrote:

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

On 7/5/2024 7:29 AM, Fred. Zwarts wrote:

Op 05.jul.2024 om 14:20 schreef olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every >>>>>>>>> pure function HHH cannot possibly reach its own ret instruction >>>>>>>>> and
halt. That HHH aborts its emulation at some point or never
aborts its
emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation. >>>>>>>> It has been proved that HHH cannot possibly correctly simulate >>>>>>>> itself.

That is false and you know it. That might not be a flat out lie
as it is
an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it >>>>>>> stops correctly simulating itself because this criteria is met:
      HHH correctly simulates its input DDD until HHH correctly >>>>>>>       determines that its simulated DDD would never stop running >>>>>>> unless
      aborted

But it would stop running.

Not if not aborted.

If you knew a little bit of programming, you would know that a
program that is programmed to abort and stop, will abort and stop,
if not aborted.

I have two software engineering patents.
HHH is a generic program that works on many different
inputs thus it is not programmed to abort and stop.
It is programmed according to this algorithm.

Apparently the algorithm is incorrect, because it does not recognize
that the simulation of HHH would reach its end, if not aborted,
because the simulated HHH aborts and returns.

In other words when a bear is running at you to kill you
there is no need to shoot it because you know that you
would shoot it so this is enough, except that the bear
then kills you.

And if all you have is a cap gun, you can't kill it and will die.

Since H can't actually kill the program that it is deciding on, only its simulation of it, it can't "kill the bear", so the bear will kill it.

HHH cannot possibly correctly simulate itself.

Unless you think that the #1 best selling author of theory
of computation textbooks is wrong then I am correct.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

You keep repeating irrelevant texts. Sipser agreed to a correct
simulation, but I have shown that you simulation is incorrect.
HHH cannot possibly correctly simulate itself.
This is supported by your x86 code, for which you admit that the
simulation cannot possibly reach its own 'ret'. Therefore, it is
unable to fully process its input.
Additional evidence is in the trace you showed, where we see that,
indeed, the simulation does not reach the 'ret' of its simulated self,
but aborts prematurely.

void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}

There is no need to abort this program, even after several recursions.

Dreaming of a program without abort is irrelevant, because HHH
*does* abort.

So, the above code shows that the incorrect simulation of DDD by >>>>>>>> HHH is
unable to reach the 'ret' instruction, because it either never >>>>>>>> aborts,
or aborts one cycle too soon, when the simulated HHH is only one >>>>>>>> cycle
from its own abort and return and then the return of DDD would >>>>>>>> follow.

The criteria is:
      HHH simulates its input DDD until HHH
      determines that its simulated DDD would never stop running >>>>>>> unless
      aborted
Richard always lies about this by making sure that he ever sees
the word
UNTIL.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 05.jul.2024 om 16:13 schreef olcott:

On 7/5/2024 9:10 AM, Fred. Zwarts wrote:

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

On 7/5/2024 7:29 AM, Fred. Zwarts wrote:

Op 05.jul.2024 om 14:20 schreef olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every >>>>>>>>> pure function HHH cannot possibly reach its own ret instruction >>>>>>>>> and
halt. That HHH aborts its emulation at some point or never
aborts its
emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation. >>>>>>>> It has been proved that HHH cannot possibly correctly simulate >>>>>>>> itself.

That is false and you know it. That might not be a flat out lie
as it is
an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it >>>>>>> stops correctly simulating itself because this criteria is met:
      HHH correctly simulates its input DDD until HHH correctly >>>>>>>       determines that its simulated DDD would never stop running >>>>>>> unless
      aborted

But it would stop running.

Not if not aborted.

If you knew a little bit of programming, you would know that a
program that is programmed to abort and stop, will abort and stop,
if not aborted.

I have two software engineering patents.
HHH is a generic program that works on many different
inputs thus it is not programmed to abort and stop.
It is programmed according to this algorithm.

Apparently the algorithm is incorrect, because it does not recognize
that the simulation of HHH would reach its end, if not aborted,
because the simulated HHH aborts and returns.

In other words when a bear is running at you to kill you
there is no need to shoot it because you know that you
would shoot it so this is enough, except that the bear
then kills you.

Nice comparison, although the conclusion is incorrect.
'Bear' compares to 'simulator'.
'running' compares to 'aborting'
'kill' compares to 'halt'.

HHH is a simulator that aborts the simulation of itself and halts.
A correct simulator of HHH should determine that HHH would abort and halt.
You have shown correct simulators that indeed perform a correct simulation. HHH, however, cannot possibly simulate itself correctly, because it
determines that HH does not abort and does not halt.
'not abort' compares to 'not running'
'not halt' compares to 'not kill'
So, this decision of HHH is like thinking that the bear is not running
and will not kill.
That is a fatal error.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-07-05 12:43:45 +0000, olcott said:

On 7/5/2024 7:26 AM, joes wrote:

Am Fri, 05 Jul 2024 07:20:04 -0500 schrieb olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every >>>>>>> pure function HHH cannot possibly reach its own ret instruction and >>>>>>> halt. That HHH aborts its emulation at some point or never aborts >>>>>>> its emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation.
It has been proved that HHH cannot possibly correctly simulate
itself.

That is false and you know it. That might not be a flat out lie as it >>>>> is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it
stops correctly simulating itself because this criteria is met:
HHH correctly simulates its input DDD until HHH correctly
determines that its simulated DDD would never stop running
unless aborted

But it would stop running.

Not if not aborted.

But it is aborted!

*It is not aborted when HHH makes its decision to abort*

If it will be aborted in future it will not run forever.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-07-06 12:54:59 +0000, olcott said:

On 7/6/2024 1:33 AM, Mikko wrote:

On 2024-07-05 12:43:45 +0000, olcott said:

On 7/5/2024 7:26 AM, joes wrote:

Am Fri, 05 Jul 2024 07:20:04 -0500 schrieb olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every >>>>>>>>> pure function HHH cannot possibly reach its own ret instruction and >>>>>>>>> halt. That HHH aborts its emulation at some point or never aborts >>>>>>>>> its emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation. >>>>>>>> It has been proved that HHH cannot possibly correctly simulate >>>>>>>> itself.

That is false and you know it. That might not be a flat out lie as it >>>>>>> is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it >>>>>>> stops correctly simulating itself because this criteria is met:
HHH correctly simulates its input DDD until HHH correctly
determines that its simulated DDD would never stop running
unless aborted

But it would stop running.

Not if not aborted.

But it is aborted!

*It is not aborted when HHH makes its decision to abort*

If it will be aborted in future it will not run forever.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then

H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

HHH(DDD) does meet this criteria. Professor Sipser is not wrong.

You have not proven that it does meet both criteria.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-07-07 13:52:31 +0000, olcott said:

On 7/7/2024 2:29 AM, Mikko wrote:

On 2024-07-06 12:54:59 +0000, olcott said:

On 7/6/2024 1:33 AM, Mikko wrote:

On 2024-07-05 12:43:45 +0000, olcott said:

On 7/5/2024 7:26 AM, joes wrote:

Am Fri, 05 Jul 2024 07:20:04 -0500 schrieb olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

DDD correctly emulated by any element of the infinite set of every >>>>>>>>>>> pure function HHH cannot possibly reach its own ret instruction and >>>>>>>>>>> halt. That HHH aborts its emulation at some point or never aborts >>>>>>>>>>> its emulation cannot possibly change this.

Ad hominem attacks always try to hide a lack of argumentation. >>>>>>>>>> It has been proved that HHH cannot possibly correctly simulate >>>>>>>>>> itself.

That is false and you know it. That might not be a flat out lie as it >>>>>>>>> is an sloppy use of language.

HHH does correctly simulate itself simulating DDD one time, then it >>>>>>>>> stops correctly simulating itself because this criteria is met: >>>>>>>>> HHH correctly simulates its input DDD until HHH correctly
determines that its simulated DDD would never stop running
unless aborted

But it would stop running.

Not if not aborted.

But it is aborted!

*It is not aborted when HHH makes its decision to abort*

If it will be aborted in future it will not run forever.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

HHH(DDD) does meet this criteria. Professor Sipser is not wrong.

You have not proven that it does meet both criteria.

Knowledge of arithmetic proves that 2 + 3 = 5.

No, it does not. Elementary knowledge of arithmetic includes the
knowledge that 2 + 3 = 5 but not the knowledge of the proof. For
practical purposes the proof is not necessary.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)