On 6/2/25 11:52 AM, olcott wrote:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

At what x86 instruction, correctly emulated does this happen.

*HHH1 never emulates itself emulating DDD*

And where does "itself" come into the behavior of x86 instructions?

ALL YOU ARE DOING IS LYING.

void DDD()
{
  HHH(DDD);
  return;
}

int main()
{
  HHH1(DDD);
}

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  ========== ============= [000021a3][0010382d][00000000] 55         push ebp      ; main() [000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

So, the above is the trace generated by the x86utm system.

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9 [00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1 [00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9

And why does HHH1 not simulate the call HHH instruction? We SHOULD see
the code for HHH after this.

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301 [00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

You mean of the INCORRECT emulation that both of your emulators do,

Since NONE of them are CORRECTLY EMULATING the input per the x86
language, you are just proving that you are just a stupid liar.

New slave_stack at:198d21
[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1 [00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main() [000021b3][0010382d][00000000] 33c0       xor eax,eax ; main() [000021b5][00103831][00000018] 5d         pop ebp     ; main() [000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

In other words, you are just putting on public display that you have no
idea what a correct emulation of a call instruction is, and thus that
you have just wasted the last two decades of your life chasing your own
lies that you have beleived.

Sorry, your stupidity is astonding, the fact that someone can be so
embedded in their lies that they can put them so out in public and not
feel any remorse.

You DO deserve that place in the lake of fire you like to project onto
others to keep you from thinking about your final resting place.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2025-06-02 15:52:53 +0000, olcott said:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

The DDD emulated (correctly or otherwise) by HHH is the same DDD as
the one emulated (correctly or otherwise) so both specify the same
behaviour. As soon as the emulations diverge (if not even sooner)
at lest one of the emulators is no longer emulating correctly.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

*HHH1 never emulates itself emulating DDD*

void DDD()
{
  HHH(DDD);
  return;
}

int main()
{
  HHH1(DDD);
}

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  ========== ============= [000021a3][0010382d][00000000] 55         push ebp      ; main() [000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9 [00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1 [00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301 [00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

New slave_stack at:198d21
[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1 [00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main() [000021b3][0010382d][00000000] 33c0       xor eax,eax ; main() [000021b5][00103831][00000018] 5d         pop ebp     ; main() [000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you still
cannot show the first instruction that is interpreted differently by HHH
and HHH1. The only difference is that HHH gives up the simulation too early. You start to call that as diverging, but that is not a divergence in simulation, but an error in the decision to give up. There is no
divergence in the simulation up to the point when that erroneous
decision is made, proving that the simulation up to that point gives no
reason for that decision.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Mon, 02 Jun 2025 10:52:53 -0500 schrieb olcott:

DDD correctly emulated by HHH diverges from DDD correctly emulated by
HHH1 as soon as HHH begins emulating itself emulating DDD, marked below. *HHH1 never emulates itself emulating DDD*

No, it simulates HHH simulating DDD, just like HHH does. Of course
"itself" refers to a different program, but they're simulating the
same code. Is that all you're getting at?

machine stack stack machine assembly address address
data code language ======== ======== ======== ==========
=============
[000021a3][0010382d][00000000] 55 push ebp ; main() [000021a4][0010382d][00000000] 8bec mov ebp,esp ; main() [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1 New slave_stack at:1038d1

Begin Local Halt Decider Simulation Execution Trace Stored at:1138d9 [00002183][001138c9][001138cd] 55 push ebp ; DDD of HHH1 [00002184][001138c9][001138cd] 8bec mov ebp,esp ; DDD of HHH1 [00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH New slave_stack at:14e2f9

Begin Local Halt Decider Simulation Execution Trace Stored at:15e301 [00002183][0015e2f1][0015e2f5] 55 push ebp ; DDD of HHH[0] [00002184][0015e2f1][0015e2f5] 8bec mov ebp,esp ; DDD of HHH[0] [00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

Here we are where HHH has simulated DDD calling HHH simulating DDD about
to call HHH again, which is where the outermost simulator stops
simulating further, so there is no more trace. HHH1 of course continues simulating.
What else do you think HHH is simulating from here on?

New slave_stack at:198d21 [00002183][001a8d19][001a8d1d] 55 push
ebp ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec mov ebp,esp ; DDD of HHH[1] [00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH Local
Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002190][001138c9][001138cd] 83c404 add esp,+04 ; DDD of HHH1 [00002193][001138cd][000015a8] 5d pop ebp ; DDD of HHH1 [00002194][001138d1][0003a980] c3 ret ; DDD of HHH1 [000021b0][0010382d][00000000] 83c404 add esp,+04 ; main() [000021b3][0010382d][00000000] 33c0 xor eax,eax ; main() [000021b5][00103831][00000018] 5d pop ebp ; main() [000021b6][00103835][00000000] c3 ret ; main()
Number of Instructions Executed(352831) == 5266 Pages

--
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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Tue, 03 Jun 2025 14:47:23 -0500 schrieb olcott:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD correctly emulated by
HHH1 as soon as HHH begins emulating itself emulating DDD, marked
below.
*HHH1 never emulates itself emulating DDD*

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you
still cannot show the first instruction that is interpreted differently
by HHH and HHH1. The only difference is that HHH gives up the
simulation too early.

As soon as HHH begins emulating itself and HHH1 NEVER begins emulating
itself THIS IS THE DIVERGENCE.

Yes, that is exactly the point where HHH aborts. There is no divergence
because there are no further simulated instructions that could be
compared. If there were, they were the same.

Would you say that HHH simulating DDD and HHH1 simulating
DDD1() {HHH1(DDD1)} are the same thing?

You start to call that as diverging, but that is not a divergence in
simulation, but an error in the decision to give up. There is no
divergence in the simulation up to the point when that erroneous
decision is made, proving that the simulation up to that point gives no
reason for that decision.

--
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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/3/25 3:57 PM, olcott wrote:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

The DDD emulated (correctly or otherwise) by HHH is the same DDD as
the one emulated (correctly or otherwise) so both specify the same
behaviour.

No they do not. When DDD calls its own emulator its behavior
is different than when DDD calls another different emulator.

HOW?

The moment that HHH begins emulating itself emulating
DDD is where the emulation by HHH and HHH1 diverge.

And what x86 instruction differed in its behavior?

All you have done so far about this is to duck, dodge and LIE.

As soon as the emulations diverge (if not even sooner)
at lest one of the emulators is no longer emulating correctly.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/3/25 3:47 PM, olcott wrote:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

*HHH1 never emulates itself emulating DDD*

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH1(DDD);
}

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() >>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9 >>> [00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301 >>> [00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

New slave_stack at:198d21
[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1
[00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main()
[000021b3][0010382d][00000000] 33c0       xor eax,eax ; main()
[000021b5][00103831][00000018] 5d         pop ebp     ; main() >>> [000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you
still cannot show the first instruction that is interpreted
differently by HHH and HHH1. The only difference is that HHH gives up
the simulation too early.

As soon as HHH begins emulating itself
and HHH1 NEVER begins emulating itself
THIS IS THE DIVERGENCE.

So, WHAT INSTRUCTION, correctly simulated did that.

Of course, all you are doing above is showing that you have always been
lying about your deciders being simulators according to the x86
language, as clearly you don't understand what a CALL instruction does.

Sorry, you are just proving that you are just a pathetic liar.

You start to call that as diverging, but that is not a divergence in
simulation, but an error in the decision to give up. There is no
divergence in the simulation up to the point when that erroneous
decision is made, proving that the simulation up to that point gives
no reason for that decision.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

The DDD emulated (correctly or otherwise) by HHH is the same DDD as
the one emulated (correctly or otherwise) so both specify the same
behaviour.

No they do not. When DDD calls its own emulator its behavior
is different than when DDD calls another different emulator.

If the input string does not unambiguously specify one and only one
behaviour it is incorrectly encoded and not a valid input string.
The halting problem of Truing machines requires that every pair of
a Turing macnine and input is descibed so that the behaviour to
be decided about is the only behaviour that meets to the description.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 03.jun.2025 om 21:47 schreef olcott:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

*HHH1 never emulates itself emulating DDD*

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH1(DDD);
}

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() >>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9 >>> [00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301 >>> [00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

New slave_stack at:198d21
[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1
[00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main()
[000021b3][0010382d][00000000] 33c0       xor eax,eax ; main()
[000021b5][00103831][00000018] 5d         pop ebp     ; main() >>> [000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you
still cannot show the first instruction that is interpreted
differently by HHH and HHH1. The only difference is that HHH gives up
the simulation too early.

As soon as HHH begins emulating itself
and HHH1 NEVER begins emulating itself
THIS IS THE DIVERGENCE.

Wrong. Again you are changing a definition. This time of 'divergence'.
The both begin simulating the same input, that is not divergence.
Divergence would be if HHH1 the would simulate not the input but
something else: itself.
If there would be divergence, you could show the first instruction that
has been simulated differently. You continued refusal to point to that instruction, shows that you are unable to show the divergence.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 04.jun.2025 om 04:37 schreef olcott:

On 6/3/2025 9:13 PM, Richard Damon wrote:

On 6/3/25 3:47 PM, olcott wrote:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

*HHH1 never emulates itself emulating DDD*

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH1(DDD);
}

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly
  address   address   data      code       language >>>>>   ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() >>>>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9 >>>>> [00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301 >>>>> [00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of
HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of >>>>> HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

New slave_stack at:198d21
[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of
HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of >>>>> HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1 >>>>> [00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main()
[000021b3][0010382d][00000000] 33c0       xor eax,eax ; main() >>>>> [000021b5][00103831][00000018] 5d         pop ebp     ; main()
[000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you
still cannot show the first instruction that is interpreted
differently by HHH and HHH1. The only difference is that HHH gives
up the simulation too early.

As soon as HHH begins emulating itself
and HHH1 NEVER begins emulating itself
THIS IS THE DIVERGENCE.

So, WHAT INSTRUCTION, correctly simulated did that.

HHH emulates DDD two times and HHH1 emulates DDD one time
the whole second time is the divergence.

That did not answer the question: WHAT INSTRUCTION, correctly simulated
did that?
You cannot point to any instruction interpreted differently by the two simulators.
It seems you understand that the trace does not show a difference, but
that the divergence is only in your interpretation of the trace.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/3/25 10:51 PM, olcott wrote:

On 6/3/2025 9:42 PM, dbush wrote:

On 6/3/2025 10:29 PM, olcott wrote:

On 6/3/2025 8:57 PM, dbush wrote:

On 6/3/2025 5:14 PM, olcott wrote:

On 6/3/2025 3:48 PM, joes wrote:

Am Tue, 03 Jun 2025 14:47:23 -0500 schrieb olcott:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD correctly
emulated by
HHH1 as soon as HHH begins emulating itself emulating DDD, marked >>>>>>>>> below.
*HHH1 never emulates itself emulating DDD*

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you >>>>>>>> still cannot show the first instruction that is interpreted
differently
by HHH and HHH1. The only difference is that HHH gives up the
simulation too early.

As soon as HHH begins emulating itself and HHH1 NEVER begins
emulating
itself THIS IS THE DIVERGENCE.

Yes, that is exactly the point where HHH aborts.

Both the divergence and the abort are shown below.

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly
  address   address   data      code       language >>>>>   ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() >>>>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9 >>>>> [00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301 >>>>> [00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of
HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of >>>>> HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:198d21

THIS IS WHERE THE DIVERGENCE OF DDD EMULATED BY HHH
AND DDD EMULATED BY HHH1 BEGINS

So how exactly do HHH and HHH1 emulate the first instruction of HHH
differently?

The question is incorrect.
HHH emulates DDD two times and HHH1 emulates DDD one time
the whole second time is the divergence.

There is no divergence if the instructions are emulated exactly the
same in both cases.

HHH1(DDD) emulates DDD exactly one time.
HHH(DDD) emulates DDD exactly two times.

The whole second time that HHH emulates DDD is
divergence.

You mean it INCORRECT imagining of what it THINKS HHH should do because
it thinks that HHH is just a correct simulator?

While HHH1(DDD) simuletes DDD calling HHH and simulates HHH actually
simulating DDD to the point that it sees HHH deciding to abort and
return 0.

The actual HHH simulates less of the behavior than HHH1 sees.

I guess in your logic 2 < 1, since HHH looking at 2 loops sees less than
HHH1 sees in 1.

Sorry, you are just proving you are a liar.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/3/25 10:37 PM, olcott wrote:

On 6/3/2025 9:13 PM, Richard Damon wrote:

On 6/3/25 3:47 PM, olcott wrote:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

*HHH1 never emulates itself emulating DDD*

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH1(DDD);
}

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly
  address   address   data      code       language >>>>>   ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() >>>>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9 >>>>> [00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301 >>>>> [00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of
HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of >>>>> HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

New slave_stack at:198d21
[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of
HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of >>>>> HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1 >>>>> [00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main()
[000021b3][0010382d][00000000] 33c0       xor eax,eax ; main() >>>>> [000021b5][00103831][00000018] 5d         pop ebp     ; main()
[000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you
still cannot show the first instruction that is interpreted
differently by HHH and HHH1. The only difference is that HHH gives
up the simulation too early.

As soon as HHH begins emulating itself
and HHH1 NEVER begins emulating itself
THIS IS THE DIVERGENCE.

So, WHAT INSTRUCTION, correctly simulated did that.

HHH emulates DDD two times and HHH1 emulates DDD one time
the whole second time is the divergence.

In other words, you are just admitting you can't point to the
instruction that things diverged, because of course the divergence
happens at an instruction not actually simulated.

ALL the call HHH instructions should be followed by a tracing of the
operation of HHH, and thus ALL your analysis is juat a LIE.

If HHH actually emualtes DDD twice (I will admit I forget which version
is which), which means that HHH emaulated DDD sees that it calls
HHH(DDD) and then, rather than actually showing the simulation of HHH simulating DDD, it shows the simulation that HHH does, and when it sees
DDD call HHH(DDD) again it aborts.

Now, what HHH1 does is emulate DDD sees it calls HHH, then actually
emulates that HHH (since it doesn't recognize it as itself)


So, in summary the emulation levels are:

For HHH:

DDD
HHH(DDD), recognized and new level of recursion.
DDD
see call to HHH(DDD) and aborts

For HHH1:
DDD
HHH(DDD), not recognize by HHH1, so it actually simulates it.
DDD
HHH(DDD)
DDD
first HHH sees call to HHH(DDD) and aborts
DDD finishes

So, actually HHH never actually tracks an emulation of itself (x86UTM
does, but HHH doesn't see that, it just see the next layer as itself),
so HHH actually sees 0 layers of actual simulation of itself.


So, all your claims are actually just lies and misuse of terms.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/3/25 10:29 PM, olcott wrote:

On 6/3/2025 8:57 PM, dbush wrote:

On 6/3/2025 5:14 PM, olcott wrote:

On 6/3/2025 3:48 PM, joes wrote:

Am Tue, 03 Jun 2025 14:47:23 -0500 schrieb olcott:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD correctly
emulated by
HHH1 as soon as HHH begins emulating itself emulating DDD, marked >>>>>>> below.
*HHH1 never emulates itself emulating DDD*

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you >>>>>> still cannot show the first instruction that is interpreted
differently
by HHH and HHH1. The only difference is that HHH gives up the
simulation too early.

As soon as HHH begins emulating itself and HHH1 NEVER begins emulating >>>>> itself THIS IS THE DIVERGENCE.

Yes, that is exactly the point where HHH aborts.

Both the divergence and the abort are shown below.

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() >>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9 >>> [00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301 >>> [00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:198d21

THIS IS WHERE THE DIVERGENCE OF DDD EMULATED BY HHH
AND DDD EMULATED BY HHH1 BEGINS

So how exactly do HHH and HHH1 emulate the first instruction of HHH
differently?

The question is incorrect.

The question is the question

HHH emulates DDD two times and HHH1 emulates DDD one time

??? HHH1 simulates farther than HHH, because HHH aborts before it gets
to the point where it sees the simulation abort.

HHH simulates DDD calling HHH(DDD) then aborts, thinking this will be
forever, because it IMAGINES (but doesn't actually simulate) the this
will cause HHH to just simulate DDD calling HHH(DDD) again and again.

HHH1 simulated DDD calling HHH(DDD) and then actually does simulate
HHH(DDD) seeing that it will simulate DDD to the point where it calls
HHH(DDD) and then aborts and returns to DDD and then DDD halts.


You seem to think that thinking improperly about what the input would do
if it was something other than what it was is simulating it.

Sorry, you are just proving you believe in lying.

the whole second time is the divergence.

No, it shows that aborting the first time was incorrect.

Sorry, you are just proving you stupidity.

Failure to provide the above explanation in your next reply or within
one hour of your next post in this newsgroup will be taken as your
official on-the-record admission that the emulations of DDD performed
by HHH and HHH1 do *not* diverge but are in fact the same up to the
point that HHH aborts.

*The above call causes HHH to emulate itself emulating DDD*
*HHH1 never emulates itself at all*

[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1
[00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main()
[000021b3][0010382d][00000000] 33c0       xor eax,eax ; main()
[000021b5][00103831][00000018] 5d         pop ebp     ; main() >>> [000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Wed, 04 Jun 2025 11:38:10 -0500 schrieb olcott:

On 6/4/2025 4:20 AM, Fred. Zwarts wrote:

Op 04.jun.2025 om 04:37 schreef olcott:

On 6/3/2025 9:13 PM, Richard Damon wrote:

On 6/3/25 3:47 PM, olcott wrote:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD correctly emulated >>>>>>> by HHH1 as soon as HHH begins emulating itself emulating DDD,
marked below.

*HHH1 never emulates itself emulating DDD*

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you >>>>>> still cannot show the first instruction that is interpreted
differently by HHH and HHH1. The only difference is that HHH gives >>>>>> up the simulation too early.

As soon as HHH begins emulating itself and HHH1 NEVER begins
emulating itself THIS IS THE DIVERGENCE.

So, WHAT INSTRUCTION, correctly simulated did that.

HHH emulates DDD two times and HHH1 emulates DDD one time the whole
second time is the divergence.

That did not answer the question: WHAT INSTRUCTION, correctly simulated
did that?

When HHH1(DDD) simulates DDD it never simulates itself. When HHH(DDD) simulates DDD then simulates itself simulating DDD the first instruction
that this simulated HHH simulates diverges from the simulation that HHH1
did.

What? No. There is simply no instruction to compare to, because HHH
doesn't simulate that far.

You cannot point to any instruction interpreted differently by the two
simulators.

There are no instructions interpreted differently. It is the fact that HHH(DDD) emulates DDD twice and HHH1(DDD) only emulates DDD once that is
the key difference.

Yes, there is no divergence. You couldn't tell the simulator just from
the trace. HHH just aborts the simulation where HHH1 continues it. You
could have said this way earlier. Disambiguation is not your strong suit.

It seems you understand that the trace does not show a difference, but
that the divergence is only in your interpretation of the trace.

--
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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/4/25 10:52 AM, olcott wrote:

On 6/4/2025 1:54 AM, Mikko wrote:

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

The DDD emulated (correctly or otherwise) by HHH is the same DDD as
the one emulated (correctly or otherwise) so both specify the same
behaviour.

No they do not. When DDD calls its own emulator its behavior
is different than when DDD calls another different emulator.

If the input string does not unambiguously specify one and only one
behaviour it is incorrectly encoded and not a valid input string.
The halting problem of Truing machines requires that every pair of
a Turing macnine and input is descibed so that the behaviour to
be decided about is the only behaviour that meets to the description.

The code proves what it proves.

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  ========== ============= [000021a3][0010382d][00000000] 55         push ebp      ; main() [000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

So what "simulation" is the above? It seems that you are showing a trace
from x86, not what HHH is doing.

Of course, you have broken x86utm here, as we shouldn't be seeing "new
slave stack" we should be seeing the simulation that x8t is doing,

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9 [00002183][001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1 [00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9

And if this is the simulation of HHH1, it is now wrong, as a call to HHH doesn't "start a new slave_stack" becaues that isn't the effect of a
call instrution. That should just push the return address onto the stack
and then continue with the same stack within the code of HHH.

I guess you are just again proving that you whole arguement about
correctly emulating per the x86 language is just a out and out lie, as
that is NOT what you are doing.

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301 [00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:198d21

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1 [00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main() [000021b3][0010382d][00000000] 33c0       xor eax,eax ; main() [000021b5][00103831][00000018] 5d         pop ebp     ; main() [000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

Since NONE of the "simulations" are per the definition of the x86
langugage, all you have done is proven that you are just being a stupid
and blantant liar, that apparently hs no idea what he is talking about,
and doesn't seem to care if his statements have any factual basis.


In other word, you are just proving that you basic nature is that of a liar.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/4/25 11:40 AM, olcott wrote:

On 6/4/2025 6:22 AM, Richard Damon wrote:

On 6/3/25 10:51 PM, olcott wrote:

On 6/3/2025 9:42 PM, dbush wrote:

On 6/3/2025 10:29 PM, olcott wrote:

On 6/3/2025 8:57 PM, dbush wrote:

On 6/3/2025 5:14 PM, olcott wrote:

On 6/3/2025 3:48 PM, joes wrote:

Am Tue, 03 Jun 2025 14:47:23 -0500 schrieb olcott:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD correctly >>>>>>>>>>> emulated by
HHH1 as soon as HHH begins emulating itself emulating DDD, >>>>>>>>>>> marked
below.
*HHH1 never emulates itself emulating DDD*

*This is the beginning of the divergence of the behavior* >>>>>>>>>>> *of DDD emulated by HHH versus DDD emulated by HHH1*

Misleading words when you change the meaning of diverging. >>>>>>>>>> Mike showed the traces side by side. Even after many requests, >>>>>>>>>> you
still cannot show the first instruction that is interpreted >>>>>>>>>> differently
by HHH and HHH1. The only difference is that HHH gives up the >>>>>>>>>> simulation too early.

As soon as HHH begins emulating itself and HHH1 NEVER begins >>>>>>>>> emulating
itself THIS IS THE DIVERGENCE.

Yes, that is exactly the point where HHH aborts.

Both the divergence and the abort are shown below.

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly >>>>>>>   address   address   data      code       language >>>>>>>   ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1 >>>>>>> New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored
at:1138d9
[00002183][001138c9][001138cd] 55         push ebp      ; DDD of
HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of
HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>> New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored
at:15e301
[00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of
HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of
HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>> New slave_stack at:198d21

THIS IS WHERE THE DIVERGENCE OF DDD EMULATED BY HHH
AND DDD EMULATED BY HHH1 BEGINS

So how exactly do HHH and HHH1 emulate the first instruction of
HHH differently?

The question is incorrect.
HHH emulates DDD two times and HHH1 emulates DDD one time
the whole second time is the divergence.

There is no divergence if the instructions are emulated exactly the
same in both cases.

HHH1(DDD) emulates DDD exactly one time.
HHH(DDD) emulates DDD exactly two times.

The whole second time that HHH emulates DDD is
divergence.

You mean it INCORRECT imagining of what it THINKS HHH should do
because it thinks that HHH is just a correct simulator?

The question is:
At exactly what point does DDD simulated by HHH
diverge from DDD simulated by HHH1?

Right, which x86 instruction, correctly simulated, had differing results.

As soon as HHH simulates itself simulating DDD it is
simulating DDD one more time than DDD simulated by
HHH1 ever gets to.

In other words, your idea of "simulation per the language of the x86
language" isn't actually based on actually emulating the actual x86 instrucitons, but instead presuming that HHH is just a pure simulator
that never aborts, and then you let it abort.

A "Call HHH" does NOT "create a new stack frame at a brand new block of
memory and then look at a different layer of simulation", but pushes the
return adderess onto the current stack, and then continues at the code
of HHH using that same stack.

In other words, your whole argument is LIES upon LIES.

Sorry, you have sunk your believability by just ignorning the meaning of
the words you are using, and stating factually incorrect statements.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/4/25 11:35 AM, olcott wrote:

On 6/4/2025 6:34 AM, Richard Damon wrote:

On 6/3/25 10:37 PM, olcott wrote:

On 6/3/2025 9:13 PM, Richard Damon wrote:

On 6/3/25 3:47 PM, olcott wrote:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

*HHH1 never emulates itself emulating DDD*

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH1(DDD);
}

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly >>>>>>>   address   address   data      code       language >>>>>>>   ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1 >>>>>>> New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored
at:1138d9
[00002183][001138c9][001138cd] 55         push ebp      ; DDD of
HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of
HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>> New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored
at:15e301
[00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of
HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of
HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>
*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

New slave_stack at:198d21
[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of
HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of
HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>>
[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1 >>>>>>> [00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main() >>>>>>> [000021b3][0010382d][00000000] 33c0       xor eax,eax ; main() >>>>>>> [000021b5][00103831][00000018] 5d         pop ebp     ; main()
[000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you >>>>>> still cannot show the first instruction that is interpreted
differently by HHH and HHH1. The only difference is that HHH gives >>>>>> up the simulation too early.

As soon as HHH begins emulating itself
and HHH1 NEVER begins emulating itself
THIS IS THE DIVERGENCE.

So, WHAT INSTRUCTION, correctly simulated did that.

HHH emulates DDD two times and HHH1 emulates DDD one time
the whole second time is the divergence.

In other words, you are just admitting you can't point to the
instruction that things diverged,

I just did you nitwit. Go back and reread it again and again
until you see that I already answered your question.

No, you pointed to an instrruction *NOT* correct simulated, but
interpreted by some strange and invalid logic.

The only case under ANY type of simulation you can replace a call to a
function with a simulation of the input to that function is if the
function is a PURE AND COMPLETE simulator, that never abort.

So, when you then have HHH abort, you admit that you operation just
wasn't valid.

In other words, you are just showing that you whole argument is just
based on LYING about what you are doing.

Sorry, your reputation is DEAD and buried in the lake of fire, where you
will be shortly joining it.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 05/06/2025 02:39, olcott wrote:

On 6/4/2025 8:28 PM, dbush wrote:

On 6/4/2025 9:08 PM, olcott wrote:

On 6/4/2025 7:41 PM, dbush wrote:

On 6/4/2025 8:32 PM, olcott wrote:

Show me this side-by-side trace and I will point out your mistake.

See below, which shows that the simulations performed by HHH and HHH1 are identical up to the
point that HHH aborts, as you have agreed on the record.

False.  The correct trace is the one I posted, which shows all levels of emulation performed by
HHH and HHH1.  See the corrections I made to your comments

It is not supposed to do that.

Are you saying it's not supposed to include /nested/ emulations? It is perfectly sensible to
include nested emulations.

It is supposed to show
the emulation of DDD by HHH1 and
the emulation of DDD by HHH
side-by-side to show the point where these
emulations diverge.

Just to be perfectly clear:

It is supposed to show
the emulation of DDD by *OUTER* HHH1 and
the emulation of DDD by *OUTER* HHH
side-by-side to show the point where these
emulations diverge.

That is exactly what my comparison shows.

Both these emulations include nested emulations, which are sensibly considered part of the reporting
of the outer emulations. As shown upthread, they do not diverge, but different emulators may choose
to abort their emulations at different points. (The emulations agree up to the point they are aborted.)

DDD emulated by HHH1              DDD emulated by HHH
[00002183] push ebp               [00002183] push ebp
[00002184] mov ebp,esp            [00002184] mov ebp,esp
[00002186] push 00002183 ; DDD    [00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH    [0000218b] call 000015c3 ; HHH

DDD emulated by HHH emulating itself
[00002183] push ebp      ;
[00002184] mov ebp,esp   ;
[00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH

LOL, I reckon I finally glimpsed your muddled thinking!

First of all, you are not really counting the reporting of nested emulations as being part of the
outer emulation, per se. As I explained in another post, that would be "a way of looking at the
question", although not such a useful way. [But viewed this way, it is /still/ the case that the
emulations exactly match up to the point where DDD aborts the emulation.]

For some time, I've been puzzled by why, if you're discounting nested emulations, do you include the
"DD emulated by HHH emulating itself" trace?!

That's your second (and fatal) mistake: you're counting it because the /immediate/ emulator is DDD,
so you think it's part of "the emulation of DDD by HHH" but not "the emulation of DDD by HHH1" !!

That is REALLY DUMB, and shows a complete lack of understanding the original question! Worse, it
suggests a basic lack of understanding of what emulation is. It's a case of scanning a sentence and
just seeing a couple of keywords you recognise, then inventing your own meaning for the sentence
based on that. No "logic" involved...

If you include the behaviour of nested emulations [as is sensible, and relevant to your overall
argument] then "DDD emulated by HHH emulating itself" is part of (outer) HHH1's emulation /AND/ part
of (outer) HHH's emulation.
*NO DIVERSION*

If you include only the behaviour of direct emulation then "DDD emulated by HHH emulating itself"
*is NOT part of (outer) HHH1's emulation AND NOT part of (outer) HHH's emulation*.
NO DIVERSION.

What you're actually doing is neither of those options. It is plain dumb - including or excluding
based on the /name/ of the immediate (one level up) emulator. We are discussing the results of the
outer emulators, and the emulator /names/ are COMPLETELY irrelevant. It is the /content/ of
emulations we are comparing. Nobody is interested in your useless redefinition of "divergence".

This also explains your oft repeated claim that HHH1 only emulates DDD once, whilst HHH emulates DDD
twice. You're counting the number of times during the nested emulation that DDD is emulated by an
immediate emulator with the same name as the outer emulator. Total nonsense, and completely
uninteresting, I'm afraid.

I'm adding emulation to the list of abstract concepts you can't deal with. As with other abstract
concepts, you've replaced it in your mind with something concrete - specific bits of code you've
written. But that leaves you with no way to evaluate questions regarding the behaviour of that
code. This explains many things, like why you didn't know using mutable static variables was a
no-no, why you put all the simulation levels in one single address space, why you conflate emulator
code and (emulation) data and so on.

It also leaves the thought that nothing can possibly be achieved by posters arguing with a person
who cannot understand /any/ of the basic (abstract) concepts needed to discuss his claims. They
would get the same results discussing quantum mechanics with their cats! :)

By my own logic, this post is totally beyond your understanding, so I've wasted my time, but as ever
the post is aimed at anyone else who wants to argue with you or even just to understand you, just in
case they've not yet had these insights themselves...


Mike.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 04.jun.2025 om 18:38 schreef olcott:

On 6/4/2025 4:20 AM, Fred. Zwarts wrote:

Op 04.jun.2025 om 04:37 schreef olcott:

On 6/3/2025 9:13 PM, Richard Damon wrote:

On 6/3/25 3:47 PM, olcott wrote:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

*HHH1 never emulates itself emulating DDD*

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH1(DDD);
}

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly >>>>>>>   address   address   data      code       language >>>>>>>   ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1 >>>>>>> New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored
at:1138d9
[00002183][001138c9][001138cd] 55         push ebp      ; DDD of
HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of
HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>> New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored
at:15e301
[00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD of
HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of
HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>
*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

New slave_stack at:198d21
[00002183][001a8d19][001a8d1d] 55         push ebp      ; DDD of
HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of
HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD >>>>>>> [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>>
[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1 >>>>>>> [00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main() >>>>>>> [000021b3][0010382d][00000000] 33c0       xor eax,eax ; main() >>>>>>> [000021b5][00103831][00000018] 5d         pop ebp     ; main()
[000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

Misleading words when you change the meaning of diverging.
Mike showed the traces side by side. Even after many requests, you >>>>>> still cannot show the first instruction that is interpreted
differently by HHH and HHH1. The only difference is that HHH gives >>>>>> up the simulation too early.

As soon as HHH begins emulating itself
and HHH1 NEVER begins emulating itself
THIS IS THE DIVERGENCE.

So, WHAT INSTRUCTION, correctly simulated did that.

HHH emulates DDD two times and HHH1 emulates DDD one time
the whole second time is the divergence.

That did not answer the question: WHAT INSTRUCTION, correctly
simulated did that?

When HHH1(DDD) simulates DDD it never simulates itself.
When HHH(DDD) simulates DDD then simulates itself simulating
DDD the first instruction that this simulated HHH simulates
diverges from the simulation that HHH1 did.

You cannot point to any instruction interpreted differently by the two
simulators.

There are no instructions interpreted differently. It is
the fact that HHH(DDD) emulates DDD twice and HHH1(DDD)
only emulates DDD once that is the key difference.

It seems you understand that the trace does not show a difference, but
that the divergence is only in your interpretation of the trace.

And you think that a logical system can be built on the meaning of
words? You change the meaning of the words again.
When somebody has set out a route through a swamp and he goes with a
friend. The path is so narrow that his friend has to place his feet in
the footsteps of the first person. Then, when we analyse the traces they
left, everybody will agree that they do not diverge, but according to
Olcott's definition of 'divergence', they diverge, because the first
trace is following his own route, but the other trace is following the
route of his friend.
But by the common sense of the meaning of the words, the traces do not
diverge when no instructions are interpreted differently.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/4/25 10:15 PM, olcott wrote:

On 6/4/2025 8:48 PM, Richard Damon wrote:

On 6/4/25 10:52 AM, olcott wrote:

On 6/4/2025 1:54 AM, Mikko wrote:

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

The DDD emulated (correctly or otherwise) by HHH is the same DDD as >>>>>> the one emulated (correctly or otherwise) so both specify the same >>>>>> behaviour.

No they do not. When DDD calls its own emulator its behavior
is different than when DDD calls another different emulator.

If the input string does not unambiguously specify one and only one
behaviour it is incorrectly encoded and not a valid input string.
The halting problem of Truing machines requires that every pair of
a Turing macnine and input is descibed so that the behaviour to
be decided about is the only behaviour that meets to the description.

The code proves what it proves.

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() >>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

So what "simulation" is the above? It seems that you are showing a
trace from x86, not what HHH is doing.

What I am showing is DDD emulated by HHH1
side-by-side with DDD emulated by HHH

No you are not, as you don't c

*They initially match up*
DDD emulated by HHH1              DDD emulated by HHH
[00002183] push ebp               [00002183] push ebp [00002184] mov ebp,esp            [00002184] mov ebp,esp [00002186] push 00002183 ; DDD    [00002186] push 00002183 ; DDD [0000218b] call 000015c3 ; HHH    [0000218b] call 000015c3 ; HHH
*The matching is now all used up*

And that this point, NEITHER of them actually correctly emulate their
input, at least not by the output that they generate.

Thus, you "argument" is just based on lies.

*Then DDD emulated by HHH does something*
*that DDD emulated by HHH1 never does*
*it emulates DDD all over again*
[00002183] push ebp      ;
[00002184] mov ebp,esp   ;
[00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH

But that ISN'T what a correct emulation of the input should do, and thus
AGAIN, I point out that you "logic" is built on the concept that lying
is valid.

A correct emulation of the input to HHH and HHH1 will be IDENTICAL, as
both use the same HHH in them. (One point you miss is that just the code
of the C function DDD is INVALID as an input, but when seens as a
program automatically include all the code it uses, that is the code of
the HHH that gives the answer you claim it correctly gives.)

This emulation will exaxtly follow the path of the directly executed
DDD, into HHH, and see it emulating DDD, and never again "directly
execute" the code of DDD in that context. Thus, a "correct emulation" of
this input will NEVER show the creation of a new context as in the path
of emulation, as at the x86 processor level, this just doesn't happen.

We WILL see the operations, that at the meta-level can be interpreted as setting up such a context and the emulation of the program in the
meta-level, but that is NOT something in the actual context of the
emulation of the input.

Your random changing of levels of abstrction just get you the wrong
answers, as you neglect some of the actions that are happening at the
outer levels of abstraction that do affect the behavior.

Perhaps in words you might understand, your "emulation" LIES about the
behavior of the HHH that it sees getting called, PRESUMING for the meta-analysis that it isn't actually the code that is there, but that it
is just a pure emulator, and by starting with this LIE, it can show that
the results will be non-halting.

But since that IS a lie, the proof isn't valid, but just another of our multitude of lies showing you don't know what you are talking about.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/4/25 9:39 PM, olcott wrote:

On 6/4/2025 8:28 PM, dbush wrote:

On 6/4/2025 9:08 PM, olcott wrote:

On 6/4/2025 7:41 PM, dbush wrote:

On 6/4/2025 8:32 PM, olcott wrote:

Show me this side-by-side trace and I will point out your mistake.

See below, which shows that the simulations performed by HHH and
HHH1 are identical up to the point that HHH aborts, as you have
agreed on the record.

False.  The correct trace is the one I posted, which shows all levels
of emulation performed by HHH and HHH1.  See the corrections I made to
your comments

It is not supposed to do that.

It is supposed to show
the emulation of DDD by HHH1 and
the emulation of DDD by HHH
side-by-side to show the point where these
emulations diverge.

But both of those, to be correct, need to follow the execution path INTO
HHH and show the operation of that code.

Since both of your "emulations" fail to do that, you are just basing
your answers on lies.

DDD emulated by HHH1              DDD emulated by HHH
[00002183] push ebp               [00002183] push ebp [00002184] mov ebp,esp            [00002184] mov ebp,esp [00002186] push 00002183 ; DDD    [00002186] push 00002183 ; DDD [0000218b] call 000015c3 ; HHH    [0000218b] call 000015c3 ; HHH

DDD emulated by HHH emulating itself
[00002183] push ebp      ;
[00002184] mov ebp,esp   ;
[00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH

So, even by your error in definition, the fact that HHH1 "emulated" how
HHH would emulated DDD, and goes FARTHER to see that HHH *WILL* abort
and return 0, gets the right answer.

HHH on the other hand, when it sees the next layer, improperly just
gives up and assumes that it won't ever stop, but since the HHH being
emulated *IS* the HHH that does abort and return, if we look at the
CORRECT emulation of the input to HHH, it would do the same thing that
HHH1 say, and that the correct answer is HALTING.

Your problem is you lie to yourself and think that the thought
experement of asking what if THIS HHH didn't abort at this point, but
continued to emulate THIS INPUT (of a program, that includes the code
that IS there, which is the HHH that does abort and return) it sees just
what HHH1 does.

Your problem is you LIE to yourself that you can look at category errors
and change what the code is that is given as the input.

SOrry, you are just proving your utter stupidity.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/4/25 10:06 PM, olcott wrote:

On 6/4/2025 8:48 PM, dbush wrote:

On 6/4/2025 9:39 PM, olcott wrote:

On 6/4/2025 8:28 PM, dbush wrote:

DDD emulated by HHH1 emulating HHH  DDD emulated by HHH emulating HHH
[00002183] push ebp      ;          [00002183] push ebp      ;
[00002184] mov ebp,esp   ;          [00002184] mov ebp,esp   ; >> [00002186] push 00002183 ; DDD      [00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH      [0000218b] call 000015c3 ; HHH
                                     ### HHH aborts ###

*That is dishonest*
HHH1 emulates DDD once and this matches
the first time that HHH emulates DDD.

DDD emulated by HHH1              DDD emulated by HHH
[00002183] push ebp               [00002183] push ebp [00002184] mov ebp,esp            [00002184] mov ebp,esp [00002186] push 00002183 ; DDD    [00002186] push 00002183 ; DDD [0000218b] call 000015c3 ; HHH    [0000218b] call 000015c3 ; HHH

*THE MATCHING IS NOW USED UP*
*THE MATCHING IS NOW USED UP*
*THE MATCHING IS NOW USED UP*

Right, becuase HHH gives up when HHH1 proves that the complete emulation
would halt.

*Then DDD emulated by HHH diverges from DDD emulated by HHH1*

DDD emulated by HHH emulating itself
[00002183] push ebp      ;
[00002184] mov ebp,esp   ;
[00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH

Which is the emulation done by HHH1, that shows that HHH will abort and
return 0 and thus DDD halts.

Which goes against the INCORRECT assumptions that HHH used, and thus HHH
was just incorrect, and you are proven to not understand how logic works,

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/4/25 10:40 PM, olcott wrote:

On 6/4/2025 8:53 PM, Richard Damon wrote:

On 6/4/25 11:40 AM, olcott wrote:

On 6/4/2025 6:22 AM, Richard Damon wrote:

On 6/3/25 10:51 PM, olcott wrote:

On 6/3/2025 9:42 PM, dbush wrote:

On 6/3/2025 10:29 PM, olcott wrote:

On 6/3/2025 8:57 PM, dbush wrote:

On 6/3/2025 5:14 PM, olcott wrote:

On 6/3/2025 3:48 PM, joes wrote:

Am Tue, 03 Jun 2025 14:47:23 -0500 schrieb olcott:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD correctly >>>>>>>>>>>>> emulated by
HHH1 as soon as HHH begins emulating itself emulating DDD, >>>>>>>>>>>>> marked
below.
*HHH1 never emulates itself emulating DDD*

*This is the beginning of the divergence of the behavior* >>>>>>>>>>>>> *of DDD emulated by HHH versus DDD emulated by HHH1*

Misleading words when you change the meaning of diverging. >>>>>>>>>>>> Mike showed the traces side by side. Even after many
requests, you
still cannot show the first instruction that is interpreted >>>>>>>>>>>> differently
by HHH and HHH1. The only difference is that HHH gives up the >>>>>>>>>>>> simulation too early.

As soon as HHH begins emulating itself and HHH1 NEVER begins >>>>>>>>>>> emulating
itself THIS IS THE DIVERGENCE.

Yes, that is exactly the point where HHH aborts.

Both the divergence and the abort are shown below.

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly >>>>>>>>>   address   address   data      code       language >>>>>>>>>   ========  ========  ========  ========== ============= >>>>>>>>> [000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>> [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call >>>>>>>>> HHH1
New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>> at:1138d9
[00002183][001138c9][001138cd] 55         push ebp      ; DDD
of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD >>>>>>>>> of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>> [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>>> New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>> at:15e301
[00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD
of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD >>>>>>>>> of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>> [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>>> New slave_stack at:198d21

THIS IS WHERE THE DIVERGENCE OF DDD EMULATED BY HHH
AND DDD EMULATED BY HHH1 BEGINS

So how exactly do HHH and HHH1 emulate the first instruction of >>>>>>>> HHH differently?

The question is incorrect.
HHH emulates DDD two times and HHH1 emulates DDD one time
the whole second time is the divergence.

There is no divergence if the instructions are emulated exactly
the same in both cases.

HHH1(DDD) emulates DDD exactly one time.
HHH(DDD) emulates DDD exactly two times.

The whole second time that HHH emulates DDD is
divergence.

You mean it INCORRECT imagining of what it THINKS HHH should do
because it thinks that HHH is just a correct simulator?

The question is:
At exactly what point does DDD simulated by HHH
diverge from DDD simulated by HHH1?

Right, which x86 instruction, correctly simulated, had differing results.

As soon as HHH simulates itself simulating DDD it is
simulating DDD one more time than DDD simulated by
HHH1 ever gets to.

In other words, your idea of "simulation per the language of the x86
language" isn't actually based on actually emulating the actual x86
instrucitons, but instead presuming that HHH is just a pure simulator
that never aborts, and then you let it abort.

Counter-factual.
HHH simulates DDD exactly twice
HHH1 simulates DDD exactly once

Dennis Bush does not seem to understand that 1 != 2

No, your traces show exactly the opposite.

HHH simuated DDD once, and when it sees DDD calling HHH(DDD) again, it
presumes this will not halt, and aborts and returns.

HHH1 when it simulates, first simulates DDD, sees it calling HHH(DDD),
and then HHH1 simulates HHH simulating DDD until that simulated HHH sees
its simulated DDD calling HHH(DDD), and then aborts its simulated
simulation and return to the simulated DDD which then halts.

Your "Second time HHH simulated DDD" isn't part of HHH's simulation, but
part of HHH1s simulation.

You just don't understand how programs work.

Of course, since all your simulations violate the definiton of a correct simulation, you are just componding lies on top of lies, showing that
you just don't know what you are talking about.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/5/25 12:45 PM, olcott wrote:

On 6/5/2025 6:29 AM, Richard Damon wrote:

On 6/4/25 10:15 PM, olcott wrote:

On 6/4/2025 8:48 PM, Richard Damon wrote:

On 6/4/25 10:52 AM, olcott wrote:

On 6/4/2025 1:54 AM, Mikko wrote:

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

The DDD emulated (correctly or otherwise) by HHH is the same DDD as >>>>>>>> the one emulated (correctly or otherwise) so both specify the same >>>>>>>> behaviour.

No they do not. When DDD calls its own emulator its behavior
is different than when DDD calls another different emulator.

If the input string does not unambiguously specify one and only one >>>>>> behaviour it is incorrectly encoded and not a valid input string.
The halting problem of Truing machines requires that every pair of >>>>>> a Turing macnine and input is descibed so that the behaviour to
be decided about is the only behaviour that meets to the description. >>>>>>

The code proves what it proves.

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly
  address   address   data      code       language >>>>>   ========  ========  ========  ========== =============
[000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() >>>>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

So what "simulation" is the above? It seems that you are showing a
trace from x86, not what HHH is doing.

What I am showing is DDD emulated by HHH1
side-by-side with DDD emulated by HHH

No you are not, as you don't c

*They initially match up*
DDD emulated by HHH1              DDD emulated by HHH
[00002183] push ebp               [00002183] push ebp
[00002184] mov ebp,esp            [00002184] mov ebp,esp
[00002186] push 00002183 ; DDD    [00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH    [0000218b] call 000015c3 ; HHH
*The matching is now all used up*

And that this point, NEITHER of them actually correctly emulate their
input, at least not by the output that they generate.

When I say correctly emulated input I mean
that every instruction that has been emulated
so far was correctly emulated.

And why wasn't the CALL instruction correctly emulated?

If you stopped before it, then the push wasn't correctly emulated, as
the last part of every instruction (except halt) is to execute the next instruction at the contents of the Program Counter.

Thus, you "argument" is just based on lies.

You argument is based on the psychosis
of insisting that a non-terminating input
be simulated completely otherwise every
single steps of this simulation is wrong.

You aree the one with a psychosis.

The only way to prove that an input is non-halting, BY DEFINITION, is to
show that the correct operation of the program (as possible shown by
correct simulation) would never stop.

The decider doesn't need to do that, but if it doesn't, then its
simulation is not the needed proof.

*Then DDD emulated by HHH does something*
*that DDD emulated by HHH1 never does*
*it emulates DDD all over again*
[00002183] push ebp      ;
[00002184] mov ebp,esp   ;
[00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH

But that ISN'T what a correct emulation of the input should do, and
thus AGAIN, I point out that you "logic" is built on the concept that
lying is valid.

Why not?

That is what the definition of the x86 processor says will happen, and
thus what a correct emulation of the code will do.


You problem is you lie to yourself about what things mean, and are too
stupid tp see that transparentcy of those lies.

All you are doing it probing how IGNORANT you are of what you are
talking about, and that you are will to just lie about it, since you
just don't care about what is correct or truthful.

A correct emulation of the input to HHH and HHH1 will be IDENTICAL, as
both use the same HHH in them. (One point you miss is that just the
code of the C function DDD is INVALID as an input, but when seens as a
program automatically include all the code it uses, that is the code
of the HHH that gives the answer you claim it correctly gives.)

This emulation will exaxtly follow the path of the directly executed
DDD, into HHH, and see it emulating DDD, and never again "directly
execute" the code of DDD in that context. Thus, a "correct emulation"
of this input will NEVER show the creation of a new context as in the
path of emulation, as at the x86 processor level, this just doesn't
happen.

We WILL see the operations, that at the meta-level can be interpreted
as setting up such a context and the emulation of the program in the
meta- level, but that is NOT something in the actual context of the
emulation of the input.

Your random changing of levels of abstrction just get you the wrong
answers, as you neglect some of the actions that are happening at the
outer levels of abstraction that do affect the behavior.

Perhaps in words you might understand, your "emulation" LIES about the
behavior of the HHH that it sees getting called, PRESUMING for the
meta- analysis that it isn't actually the code that is there, but that
it is just a pure emulator, and by starting with this LIE, it can show
that the results will be non-halting.

But since that IS a lie, the proof isn't valid, but just another of
our multitude of lies showing you don't know what you are talking about.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/5/25 12:50 PM, olcott wrote:

On 6/5/2025 6:35 AM, Richard Damon wrote:

On 6/4/25 9:39 PM, olcott wrote:

On 6/4/2025 8:28 PM, dbush wrote:

On 6/4/2025 9:08 PM, olcott wrote:

On 6/4/2025 7:41 PM, dbush wrote:

On 6/4/2025 8:32 PM, olcott wrote:

Show me this side-by-side trace and I will point out your mistake. >>>>>>

See below, which shows that the simulations performed by HHH and
HHH1 are identical up to the point that HHH aborts, as you have
agreed on the record.

False.  The correct trace is the one I posted, which shows all
levels of emulation performed by HHH and HHH1.  See the corrections
I made to your comments

It is not supposed to do that.

It is supposed to show
the emulation of DDD by HHH1 and
the emulation of DDD by HHH
side-by-side to show the point where these
emulations diverge.

But both of those, to be correct, need to follow the execution path
INTO HHH and show the operation of that code.

After three years no one besides me has
been able to understand my one half page
execution trace. Add 5,200 more pages is
sure to not help.

The problem with you short execution trace, is that is just a LIE.

We must at least consider when this code is entered.
Directly executed HHH1(DDD) simulates DDD
that calls a simulated HHH(DDD) that simulates DDD
that calls a simulated simulated HHH(DDD) that simulates DDD

Until the HHH that DDD calls decides to abort its emulation and return 0
to DDD, which means that DDD will halt.

If that HHH doesn't do that, then HHH just isn't a decider.

Your problem is you don't understand what a program is, and why that
matters.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/5/25 12:53 PM, olcott wrote:

On 6/5/2025 6:37 AM, Richard Damon wrote:

On 6/4/25 10:06 PM, olcott wrote:

On 6/4/2025 8:48 PM, dbush wrote:

On 6/4/2025 9:39 PM, olcott wrote:

On 6/4/2025 8:28 PM, dbush wrote:

DDD emulated by HHH1 emulating HHH  DDD emulated by HHH emulating HHH >>>> [00002183] push ebp      ;          [00002183] push ebp      ;
[00002184] mov ebp,esp   ;          [00002184] mov ebp,esp   ;
[00002186] push 00002183 ; DDD      [00002186] push 00002183 ; DDD >>>> [0000218b] call 000015c3 ; HHH      [0000218b] call 000015c3 ; HHH >>>>                                      ### HHH aborts ###

*That is dishonest*
HHH1 emulates DDD once and this matches
the first time that HHH emulates DDD.

DDD emulated by HHH1              DDD emulated by HHH
[00002183] push ebp               [00002183] push ebp
[00002184] mov ebp,esp            [00002184] mov ebp,esp
[00002186] push 00002183 ; DDD    [00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH    [0000218b] call 000015c3 ; HHH

*THE MATCHING IS NOW USED UP*
*THE MATCHING IS NOW USED UP*
*THE MATCHING IS NOW USED UP*

Right, becuase HHH gives up when HHH1 proves that the complete
emulation would halt.

*Then DDD emulated by HHH diverges from DDD emulated by HHH1*

DDD emulated by HHH emulating itself
[00002183] push ebp      ;
[00002184] mov ebp,esp   ;
[00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH

Which is the emulation done by HHH1, that shows that HHH will abort
and return 0 and thus DDD halts.

The above is not an emulation done by HHH1
it is done by a simulated simulated HHH.

And the simulated simulated HHH is being simulated by HHH1, and thus in
ITS processing.

You have to keep the basic facts straight
or you will never understand.

You need to follow your own advice,

But the fact that you don't know what the words mean gets in your w

Which goes against the INCORRECT assumptions that HHH used, and thus
HHH was just incorrect, and you are proven to not understand how logic
works,

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/5/25 12:57 PM, olcott wrote:

On 6/5/2025 6:42 AM, Richard Damon wrote:

On 6/4/25 10:40 PM, olcott wrote:

On 6/4/2025 8:53 PM, Richard Damon wrote:

On 6/4/25 11:40 AM, olcott wrote:

On 6/4/2025 6:22 AM, Richard Damon wrote:

On 6/3/25 10:51 PM, olcott wrote:

On 6/3/2025 9:42 PM, dbush wrote:

On 6/3/2025 10:29 PM, olcott wrote:

On 6/3/2025 8:57 PM, dbush wrote:

On 6/3/2025 5:14 PM, olcott wrote:

On 6/3/2025 3:48 PM, joes wrote:

Am Tue, 03 Jun 2025 14:47:23 -0500 schrieb olcott:

On 6/3/2025 3:28 AM, Fred. Zwarts wrote:

Op 02.jun.2025 om 17:52 schreef olcott:

DDD correctly emulated by HHH diverges from DDD correctly >>>>>>>>>>>>>>> emulated by
HHH1 as soon as HHH begins emulating itself emulating >>>>>>>>>>>>>>> DDD, marked
below.
*HHH1 never emulates itself emulating DDD*

*This is the beginning of the divergence of the behavior* >>>>>>>>>>>>>>> *of DDD emulated by HHH versus DDD emulated by HHH1* >>>>>>>>>>>>

Misleading words when you change the meaning of diverging. >>>>>>>>>>>>>> Mike showed the traces side by side. Even after many >>>>>>>>>>>>>> requests, you
still cannot show the first instruction that is
interpreted differently
by HHH and HHH1. The only difference is that HHH gives up the >>>>>>>>>>>>>> simulation too early.

As soon as HHH begins emulating itself and HHH1 NEVER >>>>>>>>>>>>> begins emulating
itself THIS IS THE DIVERGENCE.

Yes, that is exactly the point where HHH aborts.

Both the divergence and the abort are shown below.

_DDD()
[00002183] 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

  machine   stack     stack     machine    assembly >>>>>>>>>>>   address   address   data      code       language
  ========  ========  ========  ========== ============= >>>>>>>>>>> [000021a3][0010382d][00000000] 55         push ebp      ; main()
[000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; >>>>>>>>>>> push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; >>>>>>>>>>> call HHH1
New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>>>> at:1138d9
[00002183][001138c9][001138cd] 55         push ebp      ; DDD
of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD
of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; >>>>>>>>>>> push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; >>>>>>>>>>> call HHH
New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored >>>>>>>>>>> at:15e301
[00002183][0015e2f1][0015e2f5] 55         push ebp      ; DDD
of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD
of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; >>>>>>>>>>> push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; >>>>>>>>>>> call HHH
New slave_stack at:198d21

THIS IS WHERE THE DIVERGENCE OF DDD EMULATED BY HHH
AND DDD EMULATED BY HHH1 BEGINS

So how exactly do HHH and HHH1 emulate the first instruction >>>>>>>>>> of HHH differently?

The question is incorrect.
HHH emulates DDD two times and HHH1 emulates DDD one time
the whole second time is the divergence.

There is no divergence if the instructions are emulated exactly >>>>>>>> the same in both cases.

HHH1(DDD) emulates DDD exactly one time.
HHH(DDD) emulates DDD exactly two times.

The whole second time that HHH emulates DDD is
divergence.

You mean it INCORRECT imagining of what it THINKS HHH should do
because it thinks that HHH is just a correct simulator?

The question is:
At exactly what point does DDD simulated by HHH
diverge from DDD simulated by HHH1?

Right, which x86 instruction, correctly simulated, had differing
results.

As soon as HHH simulates itself simulating DDD it is
simulating DDD one more time than DDD simulated by
HHH1 ever gets to.

In other words, your idea of "simulation per the language of the x86
language" isn't actually based on actually emulating the actual x86
instrucitons, but instead presuming that HHH is just a pure
simulator that never aborts, and then you let it abort.

Counter-factual.
HHH simulates DDD exactly twice
HHH1 simulates DDD exactly once

Dennis Bush does not seem to understand that 1 != 2

No, your traces show exactly the opposite.

HHH simuated DDD once,

*HHH is simulated THREE TIMES*  Why lie ?
(Search for machine address 000021a3)

Once in the context of the HHH called by DDD, and twice within the
context of the HHH1 called by DDD (including the simulation of the
simulation of HHH)

_DDD()
*00002183* 55             push ebp
[00002184] 8bec           mov ebp,esp
[00002186] 6883210000     push 00002183 ; push DDD
[0000218b] e833f4ffff     call 000015c3 ; call HHH
[00002190] 83c404         add esp,+04
[00002193] 5d             pop ebp
[00002194] c3             ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55             push ebp
[000021a4] 8bec           mov ebp,esp
[000021a6] 6883210000     push 00002183 ; push DDD
[000021ab] e843f3ffff     call 000014f3 ; call HHH1
[000021b0] 83c404         add esp,+04
[000021b3] 33c0           xor eax,eax
[000021b5] 5d             pop ebp
[000021b6] c3             ret
Size in bytes:(0020) [000021b6]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  ========== ============= [000021a3][0010382d][00000000] 55         push ebp      ; main() [000021a4][0010382d][00000000] 8bec       mov ebp,esp   ; main() [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
New slave_stack at:1038d1

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138d9 *00002183*[001138c9][001138cd] 55         push ebp      ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec       mov ebp,esp   ; DDD of HHH1 [00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:14e2f9

Begin Local Halt Decider Simulation   Execution Trace Stored at:15e301 *00002183*[0015e2f1][0015e2f5] 55         push ebp      ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec       mov ebp,esp   ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH
New slave_stack at:198d21

*This is the beginning of the divergence of the behavior*
*of DDD emulated by HHH versus DDD emulated by HHH1*

*00002183*[001a8d19][001a8d1d] 55         push ebp      ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec       mov ebp,esp   ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[00002190][001138c9][001138cd] 83c404     add esp,+04 ; DDD of HHH1 [00002193][001138cd][000015a8] 5d         pop ebp     ; DDD of HHH1
[00002194][001138d1][0003a980] c3         ret         ; DDD of HHH1
[000021b0][0010382d][00000000] 83c404     add esp,+04 ; main() [000021b3][0010382d][00000000] 33c0       xor eax,eax ; main() [000021b5][00103831][00000018] 5d         pop ebp     ; main() [000021b6][00103835][00000000] c3         ret         ; main()
Number of Instructions Executed(352831) == 5266 Pages

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2025-06-04 14:52:50 +0000, olcott said:

On 6/4/2025 1:54 AM, Mikko wrote:

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

DDD correctly emulated by HHH diverges from DDD
correctly emulated by HHH1 as soon as HHH begins
emulating itself emulating DDD, marked below.

The DDD emulated (correctly or otherwise) by HHH is the same DDD as
the one emulated (correctly or otherwise) so both specify the same
behaviour.

No they do not. When DDD calls its own emulator its behavior
is different than when DDD calls another different emulator.

If the input string does not unambiguously specify one and only one
behaviour it is incorrectly encoded and not a valid input string.
The halting problem of Truing machines requires that every pair of
a Turing macnine and input is descibed so that the behaviour to
be decided about is the only behaviour that meets to the description.

The code proves what it proves.

Which is nothing. However, it is quite obvious from the C code
and clear enough form the assembly code that DDD does halt if
HHH(DDD) halts. That HHH(DDD) halts is not obvious from the
code but has been varified both with an exectuion of HHH(DDD)
and with an exectuion of DDD. The latter also verifies that
DDD halts, so the obvious inference from the code is redundant.

_DDD()
[00002183] 55 push ebp
[00002184] 8bec mov ebp,esp
[00002186] 6883210000 push 00002183 ; push DDD
[0000218b] e833f4ffff call 000015c3 ; call HHH
[00002190] 83c404 add esp,+04
[00002193] 5d pop ebp
[00002194] c3 ret
Size in bytes:(0018) [00002194]

_main()
[000021a3] 55 push ebp
[000021a4] 8bec mov ebp,esp
[000021a6] 6883210000 push 00002183 ; push DDD
[000021ab] e843f3ffff call 000014f3 ; call HHH1
[000021b0] 83c404 add esp,+04
[000021b3] 33c0 xor eax,eax
[000021b5] 5d pop ebp
[000021b6] c3 ret
Size in bytes:(0020) [000021b6]

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 05/06/2025 05:27, olcott wrote:

On 6/4/2025 10:55 PM, Mike Terry wrote:

On 05/06/2025 02:39, olcott wrote:

On 6/4/2025 8:28 PM, dbush wrote:

On 6/4/2025 9:08 PM, olcott wrote:

On 6/4/2025 7:41 PM, dbush wrote:

On 6/4/2025 8:32 PM, olcott wrote:

Show me this side-by-side trace and I will point out your mistake. >>>>>>

See below, which shows that the simulations performed by HHH and HHH1 are identical up to the
point that HHH aborts, as you have agreed on the record.

False.  The correct trace is the one I posted, which shows all levels of emulation performed by
HHH and HHH1.  See the corrections I made to your comments

It is not supposed to do that.

Are you saying it's not supposed to include /nested/ emulations?  It is perfectly sensible to
include nested emulations.

It can include nested simulations yet nested
simulations are in a hierarchy thus not side-by-side.
A side-by-side analysis must be side-by-side.

Hierarchies can be compared side-by-side. In the case of these traces, the hierarchy can be
"flattened" into one stream of nested simulations. You do this yourself every time you present one
of your nested simulation traces. Such a trace should include a simulation depth (or equivalent)
for each entry.

Two nested simulation traces can easily be presented side-by-side for comparisson. You are just
trying to divert attention from your own failings to properly understand the requirements.

It is supposed to show
the emulation of DDD by HHH1 and
the emulation of DDD by HHH
side-by-side to show the point where these
emulations diverge.

Just to be perfectly clear:

It is supposed to show
the emulation of DDD by *OUTER* HHH1 and
the emulation of DDD by *OUTER* HHH
side-by-side to show the point where these
emulations diverge.

No, that is not the way I was doing it.

So you were doing it wrong. No problem, but now you (hopefully) understand you can do it right.

I was
doing it all in the execution trace of HHH1(DDD).

I.e. You were doing it wrong.

The emulation of DDD by *OUTER* HHH1 is represented by the trace entries produced by HHH1 when
called from main: HHH1(DDD).

The emulation of DDD by *OUTER* HHH is represented by the trace entries produced by HHH when called
from main: HHH(DDD).

To compare them, generate those two traces and put them side by side.

In fact, since HHH1 does a full simulation, you /could/ extract the trace of HHH's emulation of DDD
from the HHH1(DDD) trace, as long as you don't get confused. Bear in mind that a given point in
HHH1's emulation will be a /different/ point in HHH's emulation. (This is what I did when I
generated the two traces to compare.)

Since there is in reality no chance of you NOT becoming confused, you should just follow the obvious
procedure of performing the two native computations HHH1(DDD) and HHH(DDD) and extracting their
emulation traces.

[..snip remainder of post, which is just confused nonsense. There is no need or point in you
explaining /why/ you did it wrong, just do it right next time..]


Mike.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Wed, 04 Jun 2025 21:15:52 -0500 schrieb olcott:

On 6/4/2025 8:48 PM, Richard Damon wrote:

On 6/4/25 10:52 AM, olcott wrote:

On 6/4/2025 1:54 AM, Mikko wrote:

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

The DDD emulated (correctly or otherwise) by HHH is the same DDD as >>>>>> the one emulated (correctly or otherwise) so both specify the same >>>>>> behaviour.

No they do not. When DDD calls its own emulator its behavior is
different than when DDD calls another different emulator.

Their code is the same and has the same meaning. DDD always calls HHH.

If the input string does not unambiguously specify one and only one
behaviour it is incorrectly encoded and not a valid input string. The
halting problem of Truing machines requires that every pair of a
Turing macnine and input is descibed so that the behaviour to be
decided about is the only behaviour that meets to the description.

The code proves what it proves.

So what "simulation" is the above? It seems that you are showing a
trace from x86, not what HHH is doing.

What I am showing is DDD emulated by HHH1 side-by-side with DDD emulated
by HHH

*They initially match up*
DDD emulated by HHH1 DDD emulated by HHH [00002183] push
ebp [00002183] push ebp [00002184] mov ebp,esp
[00002184] mov ebp,esp [00002186] push 00002183 ; DDD [00002186] push 00002183 ; DDD [0000218b] call 000015c3 ; HHH [0000218b] call
000015c3 ; HHH *The matching is now all used up*

*Then DDD emulated by HHH does something*
*that DDD emulated by HHH1 never does*
*it emulates DDD all over again*

HHH1 also does that, and more, because it doesn't abort.

--
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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Wed, 04 Jun 2025 21:36:42 -0500 schrieb olcott:

On 6/4/2025 9:10 PM, dbush wrote:

On 6/4/2025 10:06 PM, olcott wrote:

DDD emulated by HHH1              DDD emulated by HHH [00002183] push
ebp               [00002183] push ebp [00002184] mov
ebp,esp            [00002184] mov ebp,esp [00002186] push 00002183 ;
DDD    [00002186] push 00002183 ; DDD [0000218b] call 000015c3 ;
HHH    [0000218b] call 000015c3 ; HHH

*THE MATCHING IS NOW USED UP*

False.  HHH1 is still simulating the left side by simulating HHH as
shown above.

The is not the way that side-by-side comparisons of DDD simulated by
HHH1 versus DDD simulated by HHH are made.

Yes it is. Nothing is "used up". Both simulations continue, with the
same instructions:

There is a list of DDD instructions that are directly simulated by HHH1
and directly simulated by HHH right here:

DDD emulated by HHH1 DDD emulated by HHH [00002183] push
ebp [00002183] push ebp [00002184] mov ebp,esp
[00002184] mov ebp,esp [00002186] push 00002183 ; DDD [00002186] push 00002183 ; DDD [0000218b] call 000015c3 ; HHH [0000218b] call
000015c3 ; HHH

See?

HHH1 never directly emulates any other DDD.

Other than what? Either it does or or HHH doesn't either.

Another instance of HHH does directly emulate DDD.
No instance of HHH1 ever does this.

Duh, there is only one instance of HHH1. But both it and the outermost
HHH simulate HHH ("directly") simulating DDD.

--
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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Fri, 06 Jun 2025 12:35:40 -0500 schrieb olcott:

On 6/6/2025 12:26 PM, joes wrote:

Am Wed, 04 Jun 2025 21:15:52 -0500 schrieb olcott:

On 6/4/2025 8:48 PM, Richard Damon wrote:

On 6/4/25 10:52 AM, olcott wrote:

On 6/4/2025 1:54 AM, Mikko wrote:

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

The DDD emulated (correctly or otherwise) by HHH is the same DDD >>>>>>>> as the one emulated (correctly or otherwise) so both specify the >>>>>>>> same behaviour.

No they do not. When DDD calls its own emulator its behavior is
different than when DDD calls another different emulator.

Their code is the same and has the same meaning. DDD always calls HHH.

You overlooked this.

If the input string does not unambiguously specify one and only one >>>>>> behaviour it is incorrectly encoded and not a valid input string.
The halting problem of Truing machines requires that every pair of >>>>>> a Turing macnine and input is descibed so that the behaviour to be >>>>>> decided about is the only behaviour that meets to the description. >>>>>>

The code proves what it proves.

So what "simulation" is the above? It seems that you are showing a
trace from x86, not what HHH is doing.

What I am showing is DDD emulated by HHH1 side-by-side with DDD
emulated by HHH

*They initially match up*
DDD emulated by HHH1 DDD emulated by HHH [00002183] push
ebp [00002183] push ebp [00002184] mov ebp,esp
[00002184] mov ebp,esp [00002186] push 00002183 ; DDD [00002186]
push 00002183 ; DDD [0000218b] call 000015c3 ; HHH [0000218b] call
000015c3 ; HHH *The matching is now all used up*

*Then DDD emulated by HHH does something*
*that DDD emulated by HHH1 never does*
*it emulates DDD all over again*

HHH1 also does that, and more, because it doesn't abort.

HHH emulates itself emulating DDD
HHH1 NEVER emulates itself

I didn't say that it did. Like HHH it simulates HHH simulating DDD.

--
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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am Fri, 06 Jun 2025 14:18:26 -0500 schrieb olcott:

On 6/6/2025 2:14 PM, joes wrote:

Am Fri, 06 Jun 2025 12:35:40 -0500 schrieb olcott:

On 6/6/2025 12:26 PM, joes wrote:

Am Wed, 04 Jun 2025 21:15:52 -0500 schrieb olcott:

On 6/4/2025 8:48 PM, Richard Damon wrote:

On 6/4/25 10:52 AM, olcott wrote:

On 6/4/2025 1:54 AM, Mikko wrote:

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

The DDD emulated (correctly or otherwise) by HHH is the same >>>>>>>>>> DDD as the one emulated (correctly or otherwise) so both
specify the same behaviour.

No they do not. When DDD calls its own emulator its behavior is >>>>>>>>> different than when DDD calls another different emulator.

Their code is the same and has the same meaning. DDD always calls
HHH.

You overlooked this.

Please cut the above if you read it.

If the input string does not unambiguously specify one and only >>>>>>>> one behaviour it is incorrectly encoded and not a valid input
string. The halting problem of Truing machines requires that
every pair of a Turing macnine and input is descibed so that the >>>>>>>> behaviour to be decided about is the only behaviour that meets to >>>>>>>> the description.

The code proves what it proves.

So what "simulation" is the above? It seems that you are showing a >>>>>> trace from x86, not what HHH is doing.

What I am showing is DDD emulated by HHH1 side-by-side with DDD
emulated by HHH

*They initially match up*
DDD emulated by HHH1 DDD emulated by HHH [00002183]
push ebp [00002183] push ebp [00002184] mov ebp,esp
[00002184] mov ebp,esp [00002186] push 00002183 ; DDD [00002186]
push 00002183 ; DDD [0000218b] call 000015c3 ; HHH [0000218b]
call 000015c3 ; HHH *The matching is now all used up*

*Then DDD emulated by HHH does something*
*that DDD emulated by HHH1 never does*
*it emulates DDD all over again*

HHH1 also does that, and more, because it doesn't abort.

HHH emulates itself emulating DDD HHH1 NEVER emulates itself

I didn't say that it did. Like HHH it simulates HHH simulating DDD.

HHH1(DDD) simulates DDD that eventually halts. HHH(DDD) simulates DDD
that cannot possibly halt.

There is no "DDD that doesn't halt". *HHH* doesn't simulate it far enough. Indeed no simulator can simulate itself further than it has executed. That
is just a feature of simulation and has nothing to do with the halting
problem.

You must pay actual attention to the actual execution traces. When you
simply assume what these traces should be you are stupidly wrong.

I don't need to assume. Your traces show it.

--
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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/6/25 1:35 PM, olcott wrote:

On 6/6/2025 12:26 PM, joes wrote:

Am Wed, 04 Jun 2025 21:15:52 -0500 schrieb olcott:

On 6/4/2025 8:48 PM, Richard Damon wrote:

On 6/4/25 10:52 AM, olcott wrote:

On 6/4/2025 1:54 AM, Mikko wrote:

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

The DDD emulated (correctly or otherwise) by HHH is the same DDD as >>>>>>>> the one emulated (correctly or otherwise) so both specify the same >>>>>>>> behaviour.

No they do not. When DDD calls its own emulator its behavior is
different than when DDD calls another different emulator.

Their code is the same and has the same meaning. DDD always calls HHH.

If the input string does not unambiguously specify one and only one >>>>>> behaviour it is incorrectly encoded and not a valid input string. The >>>>>> halting problem of Truing machines requires that every pair of a
Turing macnine and input is descibed so that the behaviour to be
decided about is the only behaviour that meets to the description. >>>>>>

The code proves what it proves.

So what "simulation" is the above? It seems that you are showing a
trace from x86, not what HHH is doing.

What I am showing is DDD emulated by HHH1 side-by-side with DDD emulated >>> by HHH

*They initially match up*
DDD emulated by HHH1              DDD emulated by HHH [00002183] push
ebp               [00002183] push ebp [00002184] mov ebp,esp >>> [00002184] mov ebp,esp [00002186] push 00002183 ; DDD    [00002186] push >>> 00002183 ; DDD [0000218b] call 000015c3 ; HHH    [0000218b] call
000015c3 ; HHH *The matching is now all used up*

*Then DDD emulated by HHH does something*
*that DDD emulated by HHH1 never does*
*it emulates DDD all over again*

HHH1 also does that, and more, because it doesn't abort.

HHH emulates itself emulating DDD
HHH1 NEVER emulates itself

Irrelevent.

It emulates the same "input" which represents the same Program, and thus
should have the same behavior.

Of course, the fact that you admit that HHH isn't actually a program
says that everything you have done based on properties that require it
to be a program are just lies.

People with IQ's less than 5 don't know
the difference between ALWAYS and NEVER.
To these people the words ALWAYS and NEVER
are mere gibberish noises.

Right, and since a given program must ALWAYS behave the same for the
same input, your HHH is, by your claims, NEVER a program, as it seems to
always be two different programs, and thus your whole work a lie.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/6/25 4:11 PM, olcott wrote:

On 6/6/2025 2:36 PM, joes wrote:

Am Fri, 06 Jun 2025 14:18:26 -0500 schrieb olcott:

On 6/6/2025 2:14 PM, joes wrote:

Am Fri, 06 Jun 2025 12:35:40 -0500 schrieb olcott:

On 6/6/2025 12:26 PM, joes wrote:

Am Wed, 04 Jun 2025 21:15:52 -0500 schrieb olcott:

On 6/4/2025 8:48 PM, Richard Damon wrote:

On 6/4/25 10:52 AM, olcott wrote:

On 6/4/2025 1:54 AM, Mikko wrote:

On 2025-06-03 19:57:09 +0000, olcott said:

On 6/3/2025 2:37 AM, Mikko wrote:

On 2025-06-02 15:52:53 +0000, olcott said:

The DDD emulated (correctly or otherwise) by HHH is the same >>>>>>>>>>>> DDD as the one emulated (correctly or otherwise) so both >>>>>>>>>>>> specify the same behaviour.

No they do not. When DDD calls its own emulator its behavior is >>>>>>>>>>> different than when DDD calls another different emulator.

Their code is the same and has the same meaning. DDD always calls
HHH.

You overlooked this.

Please cut the above if you read it.

If the input string does not unambiguously specify one and only >>>>>>>>>> one behaviour it is incorrectly encoded and not a valid input >>>>>>>>>> string. The halting problem of Truing machines requires that >>>>>>>>>> every pair of a Turing macnine and input is descibed so that the >>>>>>>>>> behaviour to be decided about is the only behaviour that meets to >>>>>>>>>> the description.

The code proves what it proves.

So what "simulation" is the above? It seems that you are showing a >>>>>>>> trace from x86, not what HHH is doing.

What I am showing is DDD emulated by HHH1 side-by-side with DDD
emulated by HHH

*They initially match up*
DDD emulated by HHH1              DDD emulated by HHH [00002183]
push ebp               [00002183] push ebp [00002184] mov ebp,esp
[00002184] mov ebp,esp [00002186] push 00002183 ; DDD    [00002186] >>>>>>> push 00002183 ; DDD [0000218b] call 000015c3 ; HHH    [0000218b] >>>>>>> call 000015c3 ; HHH *The matching is now all used up*

*Then DDD emulated by HHH does something*
*that DDD emulated by HHH1 never does*
*it emulates DDD all over again*

HHH1 also does that, and more, because it doesn't abort.

HHH emulates itself emulating DDD HHH1 NEVER emulates itself

I didn't say that it did. Like HHH it simulates HHH simulating DDD.

HHH1(DDD) simulates DDD that eventually halts. HHH(DDD) simulates DDD
that cannot possibly halt.

There is no "DDD that doesn't halt".

You change the words that I said before
rebutting these changed words.

DDD correctly emulated by HHH cannot possibly
reach its own emulated "return" instruction
final state.

Which is an irrelevent strawman.

The input to HHH(DDD) SPECIFIES NON-HALTING BEHAVIOR.
That the caller of HHH(DDD) halts is none of the damn
business of HHH.

No, since the definition of NON-HALTING is that it will never stop after
being emulated for an unbounded number of steps.

Once we fix DDD to be a program so we can use that definition, it is
clear that any DDD based on, and was given to, an HHH that aborts and
returns 0, will eventually halt, just after that HHH gave up and aborted.

Thus, by the REAL definition, it is HALTING.

Your use of LYING DEFINITIONS just shows that you are just a LIAR.

You have no excuse for claiming otherwise, as the proper defintions have
been presented to you, and no rebuttal of those presented by you, so
that *ARE* the definition in force, which you commit LYING by recklessly ignoring.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)