Re: DDD correctly emulated by HHH cannot possibly halt

On 7/11/24 10:51 AM, olcott wrote:

On 7/10/2024 8:50 PM, Richard Damon wrote:

On 7/10/24 9:21 PM, olcott wrote:

On 7/10/2024 8:11 PM, Richard Damon wrote:

On 7/10/24 9:01 PM, olcott wrote:

On 7/10/2024 7:37 PM, Richard Damon wrote:

On 7/10/24 8:24 PM, olcott wrote:

On 7/10/2024 7:01 PM, Richard Damon wrote:

On 7/10/24 9:41 AM, olcott wrote:

On 7/10/2024 8:27 AM, joes wrote:

Am Tue, 09 Jul 2024 23:19:25 -0500 schrieb olcott:

On 7/9/2024 11:01 PM, joes wrote:
  > That means that HHH doesn't return, in particular that it doesn't
  > abort.
DDD correctly emulated by any pure function HHH that correctly emulates
1 to ∞ steps of DDD can't make it past the above line of code no matter
what.

That line being the call to itself -> it can't simulate itself.
>

*DDD NEVER HALTS*

DDD ONLY calls HHH...
>

>
void DDD()
{
   HHH(DDD);
   return;
}
>
DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ lines of DDD can't make it
to the second line of DDD no matter what.
>
>

>
Nope, DDD does if HHH(DDD) returns.
>

>
You have a dead cat in your driveway does not mean that
you have a peanut butter sandwich on your front porch.
It has taken you at least 1000 messages to see that.
>
DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ lines of DDD can't make it
to the second line of DDD no matter what.

>
WRONG, you don't seem to understand the difference between DDD and HHH's emualtion of it.
>
>

>
Would you bet your immortal soul that DDD simulated
by HHH (as provided above) would terminate normally?
>

>
That is a ambiguous statement, showing your attempt at deciet.
>

>
We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated
by each pure function x86 emulator HHH (of the infinite
set of every HHH that can possibly exist) then DDD cannot
possibly reach its own machine address of 00002174 and halt.

>
And thus you stipulate that you are a LIAR.
>
By the semantic of the x86 programming language, the only correct simulation is a FULL simulation

In other words you are trying to get away with the lie that
when 1 step of DDD is correctly emulated that 0 steps of DDD
are correctly emulated.
 Repent of this lie or risk damnation.
 

WHAT LIE?
That x86 defines that every instruction DDD/HHH that gets emulatiod included the definition that the next instruction WILL run?
That is just truth.
Calling the truth a lie is just more of your lies.
I think you have already damned yourself.