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

On 2/24/25 6:38 PM, olcott wrote:

On 2/24/2025 3:32 AM, joes wrote:

Am Sun, 23 Feb 2025 21:36:14 -0600 schrieb olcott:

On 2/23/2025 8:50 PM, Richard Damon wrote:

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

On 2/22/2025 8:41 PM, dbush wrote:

On 2/22/2025 7:45 PM, olcott wrote:

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.
When DD emulated by HHH calls HHH(DD) this call cannot possibly
return to the emulator, conclusively proving that
DD correctly simulated by HHH cannot possibly terminate normally by
reaching its own "return" instruction.
Assuming that it does return is simply stupid.

Similarly, when no_numbers_greater_than_10 emulated by F calls F(0)
this call cannot possibly return to the emulator, conclusively
proving that

Not true. The stack eventually unwinds after ten emulations.

Just like a CORRECT emulation of DD would if the HHH doing the
emulation didn't abort (but doing it by the hypothetical of NOT
changing the HHH that DD calls, since that must be the original HHH).
Your problem is you have lied to yourself about what is a "correct
emulation"

In other words you "believe" that the call from DD to HHH(DD) returns
when the above DD is emulated by HHH.
This is proven to be counter-factual by anyone that understands the
above code.

The code is wrong. The call to HHH should return, because we know that
HHH is a decider. You incorrectly turn off the abort check.
>

>
When you put code in an infinite loop then this code DOES NOT TERMINATE
NO MATTER WTF IT "SHOULD" DO.
>

 What infinite loop?
 

It is only an infinite loop if HHH fails to meet the requirements to be a decider.
 Thus, your claims are based on LIES.
 Your HHH avoids the infinite loop by aborting it emulation, but then, since it doesn't have the answer to the behavior, it guesses, and guesses wrong.
 Sorry, you are just being caught in your lies.