Re: DDD specifies recursive emulation to HHH and halting to HHH1 --- STA

Am Tue, 01 Apr 2025 21:33:30 -0500 schrieb olcott:

On 4/1/2025 8:10 PM, Richard Damon wrote:

On 4/1/25 7:33 PM, olcott wrote:

On 4/1/2025 5:09 AM, Fred. Zwarts wrote:

Op 01.apr.2025 om 04:19 schreef olcott:

On 3/31/2025 8:27 PM, Richard Damon wrote:

On 3/31/25 8:59 PM, olcott wrote:

On 3/31/2025 7:26 PM, Richard Damon wrote:

On 3/31/25 7:36 PM, olcott wrote:

On 3/31/2025 5:32 PM, Richard Damon wrote:

On 3/31/25 2:16 PM, olcott wrote:

On 3/31/2025 3:24 AM, Fred. Zwarts wrote:

Op 31.mrt.2025 om 05:13 schreef olcott:

On 3/30/2025 9:36 PM, Richard Damon wrote:

On 3/30/25 10:13 PM, olcott wrote:

On 3/30/2025 7:32 PM, Richard Damon wrote:

On 3/30/25 7:59 PM, olcott wrote:

On 3/30/2025 5:50 PM, Richard Damon wrote:

On 3/30/25 5:53 PM, olcott wrote:

DDD EMULATED BY HHH DOES SPECIFY THAT IT CANNOT
POSSIBLY REACH ITS OWN FINAL HALT STATE.
THAT IS WHAT IT SAYS AND ANYONE THAT DISAGREES IS A
DAMNED LIAR OR STUPID.
>

How does HHH emulate the call to HHH instruction

>
The semantics of the x86 language.

>
Right, which were defined by INTEL, and requires the data
emulated to be part of the input.
>

It is part of the input in the sense that HHH must emulate
itself emulating DDD. HHH it the test program thus not the
program-under-test. HHH is not asking does itself halt? It
was encoded to always halt for such inputs.

Then why does it think DDD, which only calls HHH, doesn't halt?

HHH is asking
does this input specify that it reaches its own final halt
state?

No, your HHH is asking whether it can simulate the input.

So, you admit to your equivocation.
DDD is NOT a program, if it doesn't have a DEFINITE HHH as
part of it, and thus needs to be part of the input.
>

The C function DDD specifies non-halting behavior to
termination analyzer HHH because DDD calls HHH in recursive
emulation.

DDD doesn't specify anything "to" HHH.

But only a finite recursion. DDD calls an HHH that aborts, so
there is no infinite recursion.

>
A simulating termination analyzer is always correct to abort
the simulation and reject the input as non-halting
when-so-ever this input would otherwise prevent itself from
halting.
>

But the input WILL halt, when it is correctly emulated.
>

Where "correct" is defined to disagree with the x86 language.
>

WHERE?
HHH1 correctly emualated EVERY instruction it came to, and
continued to the end.
>

And HHH emulated every instruction is came to including emulating
itself emulating DDD.

That's a tautology, as is that it didn't simulate those it didn't come to.
Note that HHH doesn't continue to the (existing) end.

Then how did it return an answer if it did this and never came to
an end?
>

*Simulating termination analyzer Principle*
It is always correct for any simulating termination analyzer to stop
simulating and reject any input that would otherwise prevent its own
termination.
>

But for a DDD that halts,

>
on the basis of dishonestly changing the subject to a different
instance of DDD, then the one proposing change of subject is
committing the straw-man deception.
>

But all identical instances of DDD behave the same,

 
The execution context differs dipshit.

Then it's not a pure function.

DDD DOES NOT F-CKING CALL HHH1 IN RECURSIVE EMULATION.

No, it calls HHH whether executed directly or simulated by whatever.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.