Re: DD specifies non-terminating behavior to HHH ---USPTO Incorporation by reference --- despicable dishonesty

On 2/23/25 12:47 PM, olcott wrote:

On 2/23/2025 5:52 AM, joes wrote:

Am Sat, 22 Feb 2025 18:45:06 -0600 schrieb olcott:

On 2/22/2025 6:02 PM, Richard Damon wrote:

On 2/22/25 11:52 AM, olcott wrote:

On 2/22/2025 5:05 AM, joes wrote:

Am Thu, 20 Feb 2025 18:25:27 -0600 schrieb olcott:

On 2/20/2025 4:38 PM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 2/20/2025 2:38 AM, Mikko wrote:

On 2025-02-20 00:31:33 +0000, olcott said:

>

I have given everyone here all of the complete source code for a
few years

True but irrelevant. OP did not specify that HHH means that
particular code.

Every post that I have been talking about for two or more years
has referred to variations of that same code.

Yes.  It would be a relief if you could move on to posting
something new and fresh.

As soon as people fully address rather than endlessly dodge my key
points I will be done.

Honestly, you're gonna die first, one way or the other.
>

Let's start with a root point.
All of the other points validate this root point.
*Simulating termination analyzer HHH correctly determines*
*the non-halt status of DD*

Since DD halts, that's dead in the water.

Despicably intentionally dishonest attempts at the straw-man deception
aside:
DD correctly simulated by HHH cannot possibly terminate normally by
reaching its own "return" instruction.

Only because that statement is based on a false premise.
Since HHH doesn't correctly simulate its input, your statement is just
a fabrication of your imagination.

>
*Correct simulation means emulates the machine code as specified* It
cannot mean imagining a different sequence than the one that the machine
code specifies. That most people here are clueless about x86 machine
code is far less than no rebuttal at all.

It's not about the machine code. The machine code of HHH specifies a
sequence where simulation is aborted, but you simulate the non-input
of a non-aborting HHH. This is not the HHH that does the simulation.
>

When DD emulated by HHH calls HHH(DD) this call cannot possibly return
to the emulator, conclusively proving that

That's bad. A decider like HHH is supposed to return.
>

 When a decider itself is called in an infinite loop
then it cannot possibly terminate unless a version
of itself its emulating this instance of itself.

But the loop is not infinite if it is a decider.
The fact that HHH DOES abort its simulation and returns an answer means that HHH needs to determine that answer to make the correct decision.
If it can't, then it just fails to get the right answer.

 In this case the infinite loop instance MUST BE ABORTED.
 _DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]
 When DD is correctly simulated by HHH according to the behavior
that the above machine code specifies then the call from DD
to HHH(DD) cannot possibly return making it impossible for DD
emulated by HHH to terminate normally.
 

But DD is NOT correctly simulated by HHH since the machine that runs DD doesn't self-distruct at the point that HHH aborts its simulation.
Your problem is you don't undetstand the meaning of "correct" and only partially right is wrong.