Re: Hypothetical possibilities --- stupid lying rebuttal by Olcott ---

On 7/30/24 10:13 PM, olcott wrote:

On 7/30/2024 8:21 PM, Richard Damon wrote:

On 7/30/24 2:42 PM, olcott wrote:

On 7/28/2024 3:10 AM, Mikko wrote:

On 2024-07-27 14:45:21 +0000, olcott said:
>

On 7/27/2024 9:28 AM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 7/27/2024 1:54 AM, Mikko wrote:

If a simulator correctly simulates a finite number of instructions
where x86 program specifies an execution of an infinite number of
instructions then the simulation deviates from x86 semantics at the
point where the simulation stops but the x86 semantics specify
countinuation.

>
>

In other words you believe that instead of recognizing a
non-halting behavior pattern, then aborting the simulation
and rejecting the input as non-halting the termination
analyzer should just get stuck in recursive simulation?

>
You're doing it again.  "In other words" is here a lie; you've just
replaced Mikko's words with something very different.
>

>
He just said that the simulation of a non-terminating input
is incorrect unless it is simulated forever.

>
I said it deviates form the x86 semantics. I didn't say whether it is
incorrect to deviate from x86 semantics.

>
The measure of DDD correctly emulated by HHH
    until HHH correctly determines that its emulated DDD would never
     stop running unless aborted...
>
is that the emulation of DDD by HHH
*DOES NOT DEVIATE FROM THE X86 SEMANTICS*

>
Which frst means it must emulate per the x86 semantics, which means

 

the call to HHH must be followed by the emulation of the x86 instructions of  HHH, not something else.
>

 *The call to HHH HAS ALWAYS BEEN FREAKING FOLLOWED*
*by the emulation of the x86 instructions of HHH*
 It seems best proven by this source-code
https://github.com/plolcott/x86utm/blob/master/Halt7.c

Which actually just proves your stupidity.
Commnets like:
   __asm nop  // The purpose of creating static local memory
   __asm nop  // directly in the function body is to make it
   __asm nop  // clear that a Turing machine computatation has
   __asm nop  // this ability by simply writing to its own tape
Which do no such thing, just showing you don't understand what a "Turing Machine" actually is,

 This level of detail was never required because we
could always see from the trace of DDD that it must
have been a call to an x86 emulator or we would
never have gotten to the first line of DDD again.
 

BUt it *ISN'T* a call to a "emumlator" but a CONDITIONAL emulator, for which your transformation is invalid.
If it is supposed to be an "emulator" by which is implied an UNCONDITIONAL emulator so you can argue that transformatin, then HHH fails to meet the requirement, and thus you proof is just a LIE.

https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
We can see from the first page of the trace on
page 38 of the file that DDD calls HHH(DDD) and
the next line is the address of HHH.

 The next call to HHH from the emulated HHH emulating
DDD calling another HHH(DDD) is more complicated.
Each emulated instruction has a bunch of emulator
instructions inbetween.
 

Right, but reveal that the path is CONDITIONAL, and not UNCONDITIONAL, and thus your logic makes a FALSE CLAIM, aka a LIE.