From Newsgroup: comp.ai.philosophy

On 7/26/2025 6:14 AM, Richard the Demon wrote:

On 7/25/25 9:29 PM, olcott wrote:

On 7/25/2025 8:22 PM, Richard the Demon wrote:

On 7/25/25 7:42 PM, olcott wrote: >>>>

_DDD()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6892210000 push 00002192  // push DDD
[0000219a] e833f4ffff call 000015d2  // call HHH
[0000219f] 83c404     add esp,+04
[000021a2] 5d         pop ebp
[000021a3] c3         ret
Size in bytes:(0018) [000021a3]

Until you provide the execution trace of DDD emulated
by HHH (according to the rules of the x86 language)
such that this emulated DDD reaches its own emulated
"ret" instruction final halt state
*you will be considered a fucking liar*

That is just a lIE.

Until you realize that HHH just doesn't do a correct simulation,

*You dishonestly changed the words that I said, as you always do*
*Here are the words that I actually said*
(according to the rules of the x86 language)

Because your HHH ignores the last step of the last instruction it
processes, that of execute the next instruction.

<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

_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192 // push DDD
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]

As soon as HHH emulates DDD then emulates itself
emulating DDD and this DDD calls HHH(DDD) to do it
again, HHH has matched a non-terminating behavior pattern.

*You cannot possibly show any actual mistake in that*

It is a verified fact that no matter how many or few
x86 instructions of DDD that HHH emulates that no
emulated DDD can possibly ever reach its own emulated
"ret" instruction final halt state.

Like I said you remain a fucking liar until you refute
that with an execution trace that conforms to the rules
of the x86 language.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/26/25 10:02 AM, olcott wrote:

On 7/26/2025 6:14 AM, Richard the Demon wrote:

On 7/25/25 9:29 PM, olcott wrote:

On 7/25/2025 8:22 PM, Richard the Demon wrote:

On 7/25/25 7:42 PM, olcott wrote: >>>>

_DDD()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6892210000 push 00002192  // push DDD
[0000219a] e833f4ffff call 000015d2  // call HHH
[0000219f] 83c404     add esp,+04
[000021a2] 5d         pop ebp
[000021a3] c3         ret
Size in bytes:(0018) [000021a3]

Until you provide the execution trace of DDD emulated
by HHH (according to the rules of the x86 language)
such that this emulated DDD reaches its own emulated
"ret" instruction final halt state
*you will be considered a fucking liar*

That is just a lIE.

Until you realize that HHH just doesn't do a correct simulation,

*You dishonestly changed the words that I said, as you always do*
*Here are the words that I actually said*
(according to the rules of the x86 language)

Because your HHH ignores the last step of the last instruction it
processes, that of execute the next instruction.

<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

You are just repeating your LIES proving your stupidity.

Since D will halt since your H aborts and return 0 as you claim to be
correct, H could not prove that a correct simulation of the input will
never halt, and it doesn't do a correct simulation of the input.

If you think partial simulations are correct, tell you surgeon next time
to only do the first half of the operation correctly and then stop, that
is enough to be correct.

Also, by you claims, youd DDD belew isn't a program, and thus a category
error to talk about its behavior, or that you can correct simulate it.

If you include the code of HHH from Halt7.c to make it a program, then
your HHH (the one that is in your specified Halt7.c) doesn't do the
correct simulation because it stops early.

_DDD()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6892210000 push 00002192  // push DDD
[0000219a] e833f4ffff call 000015d2  // call HHH
[0000219f] 83c404     add esp,+04
[000021a2] 5d         pop ebp
[000021a3] c3         ret
Size in bytes:(0018) [000021a3]

As soon as HHH emulates DDD then emulates itself
emulating DDD and this DDD calls HHH(DDD) to do it
again, HHH has matched a non-terminating behavior pattern.

Except that pattern isn't non-halting, as it exists in the simulation
done by HHH1, which reaches the final state.

*You cannot possibly show any actual mistake in that*

Sure I have.

It is a verified fact that no matter how many or few
x86 instructions of DDD that HHH emulates that no
emulated DDD can possibly ever reach its own emulated
"ret" instruction final halt state.

But those are all different input, and not allowed by you stipulation of
the specified Halt7.c

Like I said you remain a fucking liar until you refute
that with an execution trace that conforms to the rules
of the x86 language.

No, it just shows that you are the DAMNED LIAR, as I HAVE pointed out
your error, and why you request is just a strawman.

Sorry, but you have sunk your argument with you own stipulations, and
punched your ticket to that lake by your repeating the errors.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/27/2025 2:52 AM, Mikko wrote:

On 2025-07-26 14:02:15 +0000, olcott said:

On 7/26/2025 6:14 AM, Richard the Demon wrote:

On 7/25/25 9:29 PM, olcott wrote:

On 7/25/2025 8:22 PM, Richard the Demon wrote:

On 7/25/25 7:42 PM, olcott wrote: >>>>

_DDD()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6892210000 push 00002192  // push DDD
[0000219a] e833f4ffff call 000015d2  // call HHH
[0000219f] 83c404     add esp,+04
[000021a2] 5d         pop ebp
[000021a3] c3         ret
Size in bytes:(0018) [000021a3]

Until you provide the execution trace of DDD emulated
by HHH (according to the rules of the x86 language)
such that this emulated DDD reaches its own emulated
"ret" instruction final halt state
*you will be considered a fucking liar*

That is just a lIE.

Until you realize that HHH just doesn't do a correct simulation,

*You dishonestly changed the words that I said, as you always do*
*Here are the words that I actually said*
(according to the rules of the x86 language)

Because your HHH ignores the last step of the last instruction it
processes, that of execute the next instruction.

<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

_DDD()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6892210000 push 00002192  // push DDD
[0000219a] e833f4ffff call 000015d2  // call HHH
[0000219f] 83c404     add esp,+04
[000021a2] 5d         pop ebp
[000021a3] c3         ret
Size in bytes:(0018) [000021a3]

As soon as HHH emulates DDD then emulates itself
emulating DDD and this DDD calls HHH(DDD) to do it
again, HHH has matched a non-terminating behavior pattern.

That is false. The behavour of DDD is that it terminates.
Therefore no pattern it matches is a non-terminating pattern.

This ChatGPT analysis of its input below
correctly derives both of our views. I did
not bias this analysis by telling ChatGPT
what I expect to see.

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
HHH(DDD);
return;
}

int main()
{
HHH(DDD);
DDD();
}

Simulating Termination Analyzer HHH correctly simulates its input until:
(a) It detects a non-terminating behavior pattern then it aborts its simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement then it returns 1.

https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2