Re: DDD emulated by HHH --- (does not refer to prior posts)

On 9/2/24 9:16 AM, olcott wrote:

On 9/1/2024 1:52 AM, joes wrote:

Am Sat, 31 Aug 2024 14:26:21 -0500 schrieb olcott:

On 8/31/2024 1:49 PM, joes wrote:

Am Sat, 31 Aug 2024 10:19:28 -0500 schrieb olcott:

On 8/31/2024 9:59 AM, Fred. Zwarts wrote:

Op 31.aug.2024 om 14:03 schreef olcott:

On 8/31/2024 4:07 AM, Fred. Zwarts wrote:

Op 30.aug.2024 om 16:58 schreef olcott:

On 8/30/2024 9:56 AM, joes wrote:

Am Thu, 29 Aug 2024 09:07:39 -0500 schrieb olcott:

>

HHH correctly predicts what the behavior of DDD would be if this
HHH never aborted its emulation of DDD.

Problem is, DDD is then not calling itself, but the non-input of
a not-aborting HHH.

*This is before any aborting occurs*

Here is your problem. The code of the program and its meaning
according to the semantics of the x86 language, does not suddenly
change when the aborting occurs.

^ important

You cannot possibly say one damn thing about the behavior of DDD
until you first understand that a world class x86 emulator that HHH
calls does enable HHH to correctly emulate itself emulating DDD and
the following execution trace proves this.

And when this unmodified world class x86 simulator was given olcott's
DDD based on the aborting HHH as input, it showed that this has
halting behaviour.
THIS IS A VERIFIED FACT! Even olcott has verified it.
This correct simulation by the unmodified world class simulator tells
us that the program has a halting behaviour.
Your *modification* of the simulator stops the simulation before it
can see the halting behaviour and decides that the input is
non-halting. We know which one is correct: the unmodified world class
simulator, not the *modified* one, which aborts one cycle too soon..

>

Still dreaming of the HHH that does an infinite recursion?

Before we can proceed to the next step you must first agree that the
second emulation of DDD by the emulated HHH is proven to be correct on
the basis that it does emulate the first four instructions of DDD.

The fourth instruction (the call) encompasses quite a few further
instructions, which must all(!) be simulated until it returns. Only
then is it finished.

The x86utm operating system correctly emulates 100 million instructions
of DDD emulated by HHH with abort turned off.

 

And after those 100 million it still hasn’t returned.
>

 An HHH that does not abort thus never halts thus
conclusively proving that HHH must abort or never halts.
 

But that isn't the question.
THe question is does the DDD that HHH is emulating halt when correctly emulated without aborting the emulation.
Your problem is you assume you can change the code of the HHH that is being called, but that just shows you don't know the meaning of a PROGRAM.
Since this HHH doesn't *DO* the appropriate emulation, you must give the input to another emulator that does it, not change the input by changing this HHH.
YOu are just proving that your fundamental nature is to attempt to LIE.