On 10/05/2025 02:43, olcott wrote:

On 5/9/2025 8:31 PM, Richard Heathfield wrote:

On 10/05/2025 02:26, olcott wrote:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

First, try to find a way to prove that DDD is correctly
emulated by HHH. Proof by assertion will not do.

*The burden of proof is on you*

*guffaw*

You have claimed, have you not, that you have found a major flaw
in Peter Linz's proof of the Halting Problem?

The ball is very firmly in your court.

You claim  that I made a mistake yet have no actual
evidence of any actual mistake.

Your halt7.c code has a syntax error. All on its own that's
enough to prove that you made a mistake.

That you think that emulating one instruction correctly
is emulating zero instructions correctly seems dishonest.

I haven't said so, but I note that you still haven't identified
the instruction you believe to have been emulated correctly. I
wonder why.

That you cannot show one mistake proves that you know
of no mistake.

A syntax error is not just a mistake, but a fatal mistake. A C
compiler is *required* to diagnose the code and has the licence
not to yield a translation. Until you clean up your code, you
don't have a program.

--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

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

On 10/05/2025 03:16, olcott wrote:

On 5/9/2025 9:01 PM, Richard Heathfield wrote:

On 10/05/2025 02:43, olcott wrote:

On 5/9/2025 8:31 PM, Richard Heathfield wrote:

On 10/05/2025 02:26, olcott wrote:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

First, try to find a way to prove that DDD is correctly
emulated by HHH. Proof by assertion will not do.

*The burden of proof is on you*

*guffaw*

You have claimed, have you not, that you have found a major
flaw in Peter Linz's proof of the Halting Problem?

The ball is very firmly in your court.

You claim  that I made a mistake yet have no actual
evidence of any actual mistake.

Your halt7.c code has a syntax error.

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

That is a dishonest change of subject

No, it's not.

away from
the details of how DDD emulated by any HHH according
to the rules of the x86 language could possibly
reach its own "ret" instruction final halt state.

Before you can get to the x86 instructions, you have to be able
to compile HHH, which you cannot *correctly* do while it still
contains a syntax error.

ALL rebuttals only have a dishonest change of subject
as their only basis.

This is the nub of your thinking, isn't it? You can't imagine
being wrong, and in your eyes you are so obviously right that
anyone who disagrees with you must be telling lies.

What are you, six?

--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

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

On 5/9/25 9:43 PM, olcott wrote:

On 5/9/2025 8:31 PM, Richard Heathfield wrote:

On 10/05/2025 02:26, olcott wrote:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

First, try to find a way to prove that DDD is correctly emulated by
HHH. Proof by assertion will not do.

*The burden of proof is on you*
You claim  that I made a mistake yet have no actual
evidence of any actual mistake.

No, the burden of proof is on YOU that is making the claim.

Errors in your logic have been pointed out, that you are effectively
accepting by ignori9ng.

That you think that emulating one instruction correctly
is emulating zero instructions correctly seems dishonest.

But "emulating 1 instruction correctly" is not emulating the input
correctly.

That you cannot show one mistake proves that you know
of no mistake.

No, the mistakes have been pointed out, your inability to refute those
errors, and just repeat your errors and claim you don't need to prove
your claims just shows that you know your claims are just invalid.

The "accepted truth" is the accepted proof of the Turing's Halting
Theorem, which has been well scrutinized and accepted as valid.

That you claim to have a counter needs to be proven by YOU.

You just don't understand the rules of logic.

We have no oblogatyion to prove your strawman statement, you need to
prove that it is a valid criteria.

remember, the DEFINTION of the problem is that the decider must report
on the direct exectuion of the program represeted by the input.

If you think that is an invalid question, you need to prove that
assertion, using the definitions of the system, something you have shown
you don't understand since you make so many rookie errors (like thinking
you can use non-leaf C functions as replacement for programs)

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

On 5/9/25 9:26 PM, olcott wrote:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

You are just committing the strawman error.

The responce to your first claim wasn't that HHH could emulate its input
to a final state, but that by your setup, HHH couldn't emulate its input
for many steps at all.

Your HHH just can not emuolate the above input and still meet the
requirements of being a pure function.

If you remove that requirement, then the skecth of the emulation would be:

DDD push ebp
DDD moves esp to ebp
DDD pushes the address of DDD to the stack
DDD calls HHH
HHH pushes ebp
HHH oves esp to ebp
HHH loads static varialbe flag
HHH test it and sees it is 1
HHH then sets eax to 0
HHH Then returns to DDD
DDD theh increase esp by 4 to remove the parameter it pushed
DDD then pops to ebp
DDD then returns to caller and finishes.

This represents an HHH that begins by:

int HHH(ptr P) {
static bool flag = 0;
if (flag) return 0;
flag = 1;
/* rest of your code for HHH that never aborts its simulation */

}


Sorry, you claims are just invalid.

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

On 5/9/25 10:31 PM, olcott wrote:

On 5/9/2025 9:25 PM, Richard Heathfield wrote:

On 10/05/2025 03:16, olcott wrote:

On 5/9/2025 9:01 PM, Richard Heathfield wrote:

On 10/05/2025 02:43, olcott wrote:

On 5/9/2025 8:31 PM, Richard Heathfield wrote:

On 10/05/2025 02:26, olcott wrote:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

First, try to find a way to prove that DDD is correctly emulated
by HHH. Proof by assertion will not do.

*The burden of proof is on you*

*guffaw*

You have claimed, have you not, that you have found a major flaw in
Peter Linz's proof of the Halting Problem?

The ball is very firmly in your court.

You claim  that I made a mistake yet have no actual
evidence of any actual mistake.

Your halt7.c code has a syntax error.

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

That is a dishonest change of subject

No, it's not.

away from
the details of how DDD emulated by any HHH according
to the rules of the x86 language could possibly
reach its own "ret" instruction final halt state.

Before you can get to the x86 instructions, you have to be able to
compile HHH,

EVERY HYPOTHETICAL HHH THAT CAN POSSIBLY EXIST
EVERY HYPOTHETICAL HHH THAT CAN POSSIBLY EXIST
EVERY HYPOTHETICAL HHH THAT CAN POSSIBLY EXIST

Nope, not the HHH that begins with:

int HHH(ptr P) {
static bool flag = 0;
if (flag) return 0;
flag = 1;
// put here code to correctly emulate all the instrucitons of the
program P

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

That is a dishonest change of subject away from
the details of how DDD emulated by any HHH according
to the rules of the x86 language could possibly
reach its own "ret" instruction final halt state.

ALL rebuttals only have a dishonest change of subject
as their only basis.

Now, the real problem is that since the input you provide doesm't
include the code for the HHH that DDD calls, every HHH that looks at
those instruction is an impure function, and thus your saying they do
this means my program is allowed.

Otherwise, all you HHH's fail after they reach the call HHH instruciton,

Sorry, this has been pointed out many times, so you know the problem,
but you just show your stupidity by repeating it and not even trying to
answer the error pointed out.

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

Op 10.mei.2025 om 03:26 schreef olcott:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

You had the same dream again? Did that dream again wash your brain from
the traces shown to you?

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

On 2025-05-10 01:26:54 +0000, olcott said:

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

_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

If you do the impossible then everything happens, including
the reaching of the final "ret" instruction. In this case
the impossible is a correct emulation of DDD by HHH according
to the rules of the x86 language.

--
Mikko

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

Op 10.mei.2025 om 17:33 schreef olcott:

On 5/10/2025 2:40 AM, Mikko wrote:

On 2025-05-10 01:26:54 +0000, olcott said:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

If you do the impossible then everything happens, including
the reaching of the final "ret" instruction. In this case
the impossible is a correct emulation of DDD by HHH according
to the rules of the x86 language.

It is not impossible for DDD to be emulated
by HHH according to the rules of the x86 language.
Here it is actually doing this.

_DDD()
[0000219e] 55             push ebp
[0000219f] 8bec           mov ebp,esp
[000021a1] 689e210000     push 0000219e
[000021a6] e843f4ffff     call 000015ee
[000021ab] 83c404         add esp,+04
[000021ae] 5d             pop ebp
[000021af] c3             ret
Size in bytes:(0018) [000021af]

_main()
[000021be] 55             push ebp
[000021bf] 8bec           mov ebp,esp
[000021c1] 689e210000     push 0000219e
[000021c6] e823f4ffff     call 000015ee
[000021cb] 83c404         add esp,+04
[000021ce] 50             push eax
[000021cf] 685f070000     push 0000075f
[000021d4] e8a5e5ffff     call 0000077e
[000021d9] 83c408         add esp,+08
[000021dc] 33c0           xor eax,eax
[000021de] 5d             pop ebp
[000021df] c3             ret
Size in bytes:(0034) [000021df]

 machine   stack     stack     machine        assembly
 address   address   data      code           language
 ========  ========  ========  ============== ============= [000021be][00103872][00000000] 55             push ebp [000021bf][00103872][00000000] 8bec           mov ebp,esp [000021c1][0010386e][0000219e] 689e210000     push 0000219e // push DDD [000021c6][0010386a][000021cb] e823f4ffff     call 000015ee // call HHH New slave_stack at:103916

Begin Local Halt Decider Simulation   Execution Trace Stored at:11391e [0000219e][0011390e][00113912] 55             push ebp [0000219f][0011390e][00113912] 8bec           mov ebp,esp [000021a1][0011390a][0000219e] 689e210000     push 0000219e // push DDD [000021a6][00113906][000021ab] e843f4ffff     call 000015ee // call HHH

The following shows the result of HHH emulating
itself emulating DDD. x86utm is a cooperative
multi-tasking operating system.

New slave_stack at:14e33e
[0000219e][0015e336][0015e33a] 55             push ebp [0000219f][0015e336][0015e33a] 8bec           mov ebp,esp [000021a1][0015e332][0000219e] 689e210000     push 0000219e // push DDD [000021a6][0015e32e][000021ab] e843f4ffff     call 000015ee // call HHH Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[000021cb][00103872][00000000] 83c404         add esp,+04 [000021ce][0010386e][00000000] 50             push eax [000021cf][0010386a][0000075f] 685f070000     push 0000075f [000021d4][0010386a][0000075f] e8a5e5ffff     call 0000077e
Input_Halts = 0
[000021d9][00103872][00000000] 83c408         add esp,+08 [000021dc][00103872][00000000] 33c0           xor eax,eax [000021de][00103876][00000018] 5d             pop ebp [000021df][0010387a][00000000] c3             ret
Number of Instructions Executed(10069) == 150 Pages

You seems to forget what you have said before. This has been posted
several times already and each time it was shown to be irrelevant. What
you show is that the simulated HHH aborts, but that the simulating HHH
misses that verifiable fact in its simulation.
This buggy HHH is part of the input, which makes that the input
specifies a buggy halting program. That HHH is blind for the
specification does not mean that the input does not specify it.

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

On 5/10/25 11:33 AM, olcott wrote:

On 5/10/2025 2:40 AM, Mikko wrote:

On 2025-05-10 01:26:54 +0000, olcott said:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

If you do the impossible then everything happens, including
the reaching of the final "ret" instruction. In this case
the impossible is a correct emulation of DDD by HHH according
to the rules of the x86 language.

It is not impossible for DDD to be emulated
by HHH according to the rules of the x86 language.
Here it is actually doing this.

Sure it is.

_DDD()
[0000219e] 55             push ebp
[0000219f] 8bec           mov ebp,esp
[000021a1] 689e210000     push 0000219e
[000021a6] e843f4ffff     call 000015ee
[000021ab] 83c404         add esp,+04
[000021ae] 5d             pop ebp
[000021af] c3             ret
Size in bytes:(0018) [000021af]

_main()
[000021be] 55             push ebp
[000021bf] 8bec           mov ebp,esp
[000021c1] 689e210000     push 0000219e
[000021c6] e823f4ffff     call 000015ee
[000021cb] 83c404         add esp,+04
[000021ce] 50             push eax
[000021cf] 685f070000     push 0000075f
[000021d4] e8a5e5ffff     call 0000077e
[000021d9] 83c408         add esp,+08
[000021dc] 33c0           xor eax,eax
[000021de] 5d             pop ebp
[000021df] c3             ret
Size in bytes:(0034) [000021df]

So, this output it

 machine   stack     stack     machine        assembly
 address   address   data      code           language
 ========  ========  ========  ============== ============= [000021be][00103872][00000000] 55             push ebp [000021bf][00103872][00000000] 8bec           mov ebp,esp [000021c1][0010386e][0000219e] 689e210000     push 0000219e // push DDD [000021c6][0010386a][000021cb] e823f4ffff     call 000015ee // call HHH New slave_stack at:103916

And thus we see that you definition of "correctly simulating" even at
the level of your x86utm is incorrect, as the call HHH should be showing
the code of HHH, not just jump to the code of DDD.

Note, the "correct execution trace of DDD" that you are claiming this to
be should show the code of HHH, not the results of the simulation that
it generated.

You are off by a level of abstraction.

Begin Local Halt Decider Simulation   Execution Trace Stored at:11391e

[0000219e][0011390e][00113912] 55             push ebp [0000219f][0011390e][00113912] 8bec           mov ebp,esp [000021a1][0011390a][0000219e] 689e210000     push 0000219e // push DDD [000021a6][00113906][000021ab] e843f4ffff     call 000015ee // call HHH

The following shows the result of HHH emulating
itself emulating DDD. x86utm is a cooperative
multi-tasking operating system.

No it doesn't, as pointed out below.

New slave_stack at:14e33e
[0000219e][0015e336][0015e33a] 55             push ebp [0000219f][0015e336][0015e33a] 8bec           mov ebp,esp [000021a1][0015e332][0000219e] 689e210000     push 0000219e // push DDD [000021a6][0015e32e][000021ab] e843f4ffff     call 000015ee // call HHH Local Halt Decider: Infinite Recursion Detected Simulation Stopped

And this PROVES it, HHH did not correctly emulate the CALL HHH
instrution, as BY THE DEFINITION OF THE x86 language, the next
instruciton emulatd needed to be at 000015EE, not 000021CB

[000021cb][00103872][00000000] 83c404         add esp,+04 [000021ce][0010386e][00000000] 50             push eax [000021cf][0010386a][0000075f] 685f070000     push 0000075f [000021d4][0010386a][0000075f] e8a5e5ffff     call 0000077e
Input_Halts = 0
[000021d9][00103872][00000000] 83c408         add esp,+08 [000021dc][00103872][00000000] 33c0           xor eax,eax [000021de][00103876][00000018] 5d             pop ebp [000021df][0010387a][00000000] c3             ret
Number of Instructions Executed(10069) == 150 Pages

So, all you have demonstrated is that you have hacked up the previously
working emualator to make it not correctly report on the actual
emulation it does.

The report from it SHOULD show every instruction executed, NOT skipping
the instrucitons of HHH.

As far as we can tell from this, niether 8x6utm nor HHH actually emulate
the code in HHH, but might just call it.

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

On 2025-05-10 15:33:50 +0000, olcott said:

On 5/10/2025 2:40 AM, Mikko wrote:

On 2025-05-10 01:26:54 +0000, olcott said:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

If you do the impossible then everything happens, including
the reaching of the final "ret" instruction. In this case
the impossible is a correct emulation of DDD by HHH according
to the rules of the x86 language.

It is not impossible for DDD to be emulated
by HHH according to the rules of the x86 language.

You may call it possible or impossible but either way, HHH does
not emulate the final "ret" isntruction.

Here it is actually doing this.

_DDD()
[0000219e] 55 push ebp
[0000219f] 8bec mov ebp,esp
[000021a1] 689e210000 push 0000219e
[000021a6] e843f4ffff call 000015ee
[000021ab] 83c404 add esp,+04
[000021ae] 5d pop ebp
[000021af] c3 ret
Size in bytes:(0018) [000021af]

_main()
[000021be] 55 push ebp
[000021bf] 8bec mov ebp,esp
[000021c1] 689e210000 push 0000219e
[000021c6] e823f4ffff call 000015ee
[000021cb] 83c404 add esp,+04
[000021ce] 50 push eax
[000021cf] 685f070000 push 0000075f
[000021d4] e8a5e5ffff call 0000077e
[000021d9] 83c408 add esp,+08
[000021dc] 33c0 xor eax,eax
[000021de] 5d pop ebp
[000021df] c3 ret
Size in bytes:(0034) [000021df]

machine stack stack machine assembly
address address data code language
======== ======== ======== ============== ============= [000021be][00103872][00000000] 55 push ebp [000021bf][00103872][00000000] 8bec mov ebp,esp [000021c1][0010386e][0000219e] 689e210000 push 0000219e // push DDD [000021c6][0010386a][000021cb] e823f4ffff call 000015ee // call HHH
New slave_stack at:103916

Begin Local Halt Decider Simulation Execution Trace Stored at:11391e [0000219e][0011390e][00113912] 55 push ebp [0000219f][0011390e][00113912] 8bec mov ebp,esp [000021a1][0011390a][0000219e] 689e210000 push 0000219e // push DDD [000021a6][00113906][000021ab] e843f4ffff call 000015ee // call HHH

The following shows the result of HHH emulating
itself emulating DDD. x86utm is a cooperative
multi-tasking operating system.

New slave_stack at:14e33e
[0000219e][0015e336][0015e33a] 55 push ebp [0000219f][0015e336][0015e33a] 8bec mov ebp,esp [000021a1][0015e332][0000219e] 689e210000 push 0000219e // push DDD [000021a6][0015e32e][000021ab] e843f4ffff call 000015ee // call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[000021cb][00103872][00000000] 83c404 add esp,+04 [000021ce][0010386e][00000000] 50 push eax [000021cf][0010386a][0000075f] 685f070000 push 0000075f [000021d4][0010386a][0000075f] e8a5e5ffff call 0000077e
Input_Halts = 0
[000021d9][00103872][00000000] 83c408 add esp,+08 [000021dc][00103872][00000000] 33c0 xor eax,eax [000021de][00103876][00000018] 5d pop ebp [000021df][0010387a][00000000] c3 ret
Number of Instructions Executed(10069) == 150 Pages

Apparently you said that the last "ret" is not acutally emulated but
only its emulation is emulated.

Your trace lacks the indication of which lines are actually trace lines
and which are output lines from the emulated program that only look like
trace lines.

--
Mikko

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

On 5/11/25 12:23 PM, olcott wrote:

On 5/11/2025 4:20 AM, Mikko wrote:

On 2025-05-10 15:33:50 +0000, olcott said:

On 5/10/2025 2:40 AM, Mikko wrote:

On 2025-05-10 01:26:54 +0000, olcott said:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

If you do the impossible then everything happens, including
the reaching of the final "ret" instruction. In this case
the impossible is a correct emulation of DDD by HHH according
to the rules of the x86 language.

It is not impossible for DDD to be emulated
by HHH according to the rules of the x86 language.

You may call it possible or impossible but either way, HHH does
not emulate the final "ret" isntruction.

Here it is actually doing this.

_DDD()
[0000219e] 55             push ebp
[0000219f] 8bec           mov ebp,esp
[000021a1] 689e210000     push 0000219e
[000021a6] e843f4ffff     call 000015ee
[000021ab] 83c404         add esp,+04
[000021ae] 5d             pop ebp
[000021af] c3             ret
Size in bytes:(0018) [000021af]

_main()
[000021be] 55             push ebp
[000021bf] 8bec           mov ebp,esp
[000021c1] 689e210000     push 0000219e
[000021c6] e823f4ffff     call 000015ee
[000021cb] 83c404         add esp,+04
[000021ce] 50             push eax
[000021cf] 685f070000     push 0000075f
[000021d4] e8a5e5ffff     call 0000077e
[000021d9] 83c408         add esp,+08
[000021dc] 33c0           xor eax,eax
[000021de] 5d             pop ebp
[000021df] c3             ret
Size in bytes:(0034) [000021df]

  machine   stack     stack     machine        assembly >>>   address   address   data      code           language >>>   ========  ========  ========  ============== =============
[000021be][00103872][00000000] 55             push ebp
[000021bf][00103872][00000000] 8bec           mov ebp,esp
[000021c1][0010386e][0000219e] 689e210000     push 0000219e // push DDD >>> [000021c6][0010386a][000021cb] e823f4ffff     call 000015ee // call HHH >>> New slave_stack at:103916

Begin Local Halt Decider Simulation   Execution Trace Stored at:11391e >>> [0000219e][0011390e][00113912] 55             push ebp
[0000219f][0011390e][00113912] 8bec           mov ebp,esp
[000021a1][0011390a][0000219e] 689e210000     push 0000219e // push DDD >>> [000021a6][00113906][000021ab] e843f4ffff     call 000015ee // call HHH >>>
The following shows the result of HHH emulating
itself emulating DDD. x86utm is a cooperative
multi-tasking operating system.

New slave_stack at:14e33e
[0000219e][0015e336][0015e33a] 55             push ebp
[0000219f][0015e336][0015e33a] 8bec           mov ebp,esp
[000021a1][0015e332][0000219e] 689e210000     push 0000219e // push DDD >>> [000021a6][0015e32e][000021ab] e843f4ffff     call 000015ee // call HHH >>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[000021cb][00103872][00000000] 83c404         add esp,+04
[000021ce][0010386e][00000000] 50             push eax
[000021cf][0010386a][0000075f] 685f070000     push 0000075f
[000021d4][0010386a][0000075f] e8a5e5ffff     call 0000077e
Input_Halts = 0
[000021d9][00103872][00000000] 83c408         add esp,+08
[000021dc][00103872][00000000] 33c0           xor eax,eax
[000021de][00103876][00000018] 5d             pop ebp
[000021df][0010387a][00000000] c3             ret
Number of Instructions Executed(10069) == 150 Pages

Apparently you said that the last "ret" is not acutally emulated but
only its emulation is emulated.

Your trace lacks the indication of which lines are actually trace lines
and which are output lines from the emulated program that only look like
trace lines.

You must use the machine addresses to see what code
is being emulated. New slave_stack indicate that
a new process context has been created. Code following
that is being emulated.

New slave_stack at:14e33e indicates that HHH is
about to emulate itself emulating DDD.

But "New slave stack" isn't something an x86 instruction does at the instruction level

Thus, this is NOT the simulation you claimed, and thus doesn't prove any
of your claims, t just shows you are just a stupid liar.

Now, if you want to claim a different type of simulation, then you need
to define what HHH is.

Is is a correct simulator (to allow such a operation) at which point it
CAN NOT (in ANY copy of it) abort its simulation.

Or is it possible just a partial simulation, in which case you trace is
just incorrect, as you can't do that with partial simultors.

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

On 5/12/25 10:36 AM, olcott wrote:

On 5/12/2025 2:39 AM, Mikko wrote:

On 2025-05-11 16:23:29 +0000, olcott said:

On 5/11/2025 4:20 AM, Mikko wrote:

On 2025-05-10 15:33:50 +0000, olcott said:

On 5/10/2025 2:40 AM, Mikko wrote:

On 2025-05-10 01:26:54 +0000, olcott said:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

If you do the impossible then everything happens, including
the reaching of the final "ret" instruction. In this case
the impossible is a correct emulation of DDD by HHH according
to the rules of the x86 language.

It is not impossible for DDD to be emulated
by HHH according to the rules of the x86 language.

You may call it possible or impossible but either way, HHH does
not emulate the final "ret" isntruction.

Here it is actually doing this.

_DDD()
[0000219e] 55             push ebp
[0000219f] 8bec           mov ebp,esp
[000021a1] 689e210000     push 0000219e
[000021a6] e843f4ffff     call 000015ee
[000021ab] 83c404         add esp,+04
[000021ae] 5d             pop ebp
[000021af] c3             ret
Size in bytes:(0018) [000021af]

_main()
[000021be] 55             push ebp
[000021bf] 8bec           mov ebp,esp
[000021c1] 689e210000     push 0000219e
[000021c6] e823f4ffff     call 000015ee
[000021cb] 83c404         add esp,+04
[000021ce] 50             push eax
[000021cf] 685f070000     push 0000075f
[000021d4] e8a5e5ffff     call 0000077e
[000021d9] 83c408         add esp,+08
[000021dc] 33c0           xor eax,eax
[000021de] 5d             pop ebp
[000021df] c3             ret
Size in bytes:(0034) [000021df]

  machine   stack     stack     machine        assembly >>>>>   address   address   data      code           language
  ========  ========  ========  ============== =============
[000021be][00103872][00000000] 55             push ebp
[000021bf][00103872][00000000] 8bec           mov ebp,esp
[000021c1][0010386e][0000219e] 689e210000     push 0000219e // push >>>>> DDD
[000021c6][0010386a][000021cb] e823f4ffff     call 000015ee // call >>>>> HHH
New slave_stack at:103916

Begin Local Halt Decider Simulation   Execution Trace Stored at:11391e >>>>> [0000219e][0011390e][00113912] 55             push ebp
[0000219f][0011390e][00113912] 8bec           mov ebp,esp
[000021a1][0011390a][0000219e] 689e210000     push 0000219e // push >>>>> DDD
[000021a6][00113906][000021ab] e843f4ffff     call 000015ee // call >>>>> HHH

The following shows the result of HHH emulating
itself emulating DDD. x86utm is a cooperative
multi-tasking operating system.

New slave_stack at:14e33e
[0000219e][0015e336][0015e33a] 55             push ebp
[0000219f][0015e336][0015e33a] 8bec           mov ebp,esp
[000021a1][0015e332][0000219e] 689e210000     push 0000219e // push >>>>> DDD
[000021a6][0015e32e][000021ab] e843f4ffff     call 000015ee // call >>>>> HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[000021cb][00103872][00000000] 83c404         add esp,+04
[000021ce][0010386e][00000000] 50             push eax
[000021cf][0010386a][0000075f] 685f070000     push 0000075f
[000021d4][0010386a][0000075f] e8a5e5ffff     call 0000077e
Input_Halts = 0
[000021d9][00103872][00000000] 83c408         add esp,+08
[000021dc][00103872][00000000] 33c0           xor eax,eax
[000021de][00103876][00000018] 5d             pop ebp
[000021df][0010387a][00000000] c3             ret
Number of Instructions Executed(10069) == 150 Pages

Apparently you said that the last "ret" is not acutally emulated but
only its emulation is emulated.

Your trace lacks the indication of which lines are actually trace lines >>>> and which are output lines from the emulated program that only look
like
trace lines.

You must use the machine addresses to see what code
is being emulated. New slave_stack indicate that
a new process context has been created. Code following
that is being emulated.

Nowhere is said that a slave stack is disposed. Apparently no emulation
is ever completed. But your output is too defective to be sure.

New slave_stack at:14e33e indicates that HHH is
about to emulate itself emulating DDD.

But not to the completion of the emulated emulation.

When what is essentially infinite is specified
there is no transition to a final halt state.

It is nutty to require a simulating termination
analyzer to simulate a non-terminating input forever.

No, it isn't "essential infinite" as your HHH that answer ALWAYS aborts
its emulation after a finite time, and thus the input only has strictly
finte recursion.

HHH just lies to itself, believing the lie you told it, that the HHH
that DDD calls isn't the same as it.

Sorry, you are just showing your logic assuems lying is valid logic.

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

On 2025-05-12 14:41:38 +0000, Richard Heathfield said:

On 12/05/2025 15:36, olcott wrote:

<snip>

It is nutty to require a simulating termination
analyzer to simulate a non-terminating input forever.

I have to agree with you here. In fact, you've put your finger on the
precise reason that it's nutty to try to analyse a program's
termination behaviour by simulating it.

The latter is not as nutty as the former. The problem whether a program terminates in a reasonable time for a particular input is determinable
with simulation.

--
Mikko

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

On 2025-05-12 15:54:39 +0000, olcott said:

On 5/12/2025 9:41 AM, Richard Heathfield wrote:

On 12/05/2025 15:36, olcott wrote:

<snip>

It is nutty to require a simulating termination
analyzer to simulate a non-terminating input forever.

I have to agree with you here. In fact, you've put your finger on the
precise reason that it's nutty to try to analyse a program's
termination behaviour by simulating it.

Unless like every competent programmer
HHH can spot the repeating pattern of DDD
correctly emulated by HHH in N steps of
correct emulation.

A competent programmer, at least if you pay enough, may find that HHH
does not do an infintely recursive simulation and returns to DDD, which
then halts.

--
Mikko

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

On 2025-05-12 14:36:01 +0000, olcott said:

On 5/12/2025 2:39 AM, Mikko wrote:

On 2025-05-11 16:23:29 +0000, olcott said:

On 5/11/2025 4:20 AM, Mikko wrote:

On 2025-05-10 15:33:50 +0000, olcott said:

On 5/10/2025 2:40 AM, Mikko wrote:

On 2025-05-10 01:26:54 +0000, olcott said:

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

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

Try to show how DDD emulated by HHH according to the
rules of the x86 language reaches its own "ret"
instruction final halt state.

If you do the impossible then everything happens, including
the reaching of the final "ret" instruction. In this case
the impossible is a correct emulation of DDD by HHH according
to the rules of the x86 language.

It is not impossible for DDD to be emulated
by HHH according to the rules of the x86 language.

You may call it possible or impossible but either way, HHH does
not emulate the final "ret" isntruction.

Here it is actually doing this.

_DDD()
[0000219e] 55             push ebp
[0000219f] 8bec           mov ebp,esp
[000021a1] 689e210000     push 0000219e
[000021a6] e843f4ffff     call 000015ee
[000021ab] 83c404         add esp,+04
[000021ae] 5d             pop ebp
[000021af] c3             ret
Size in bytes:(0018) [000021af]

_main()
[000021be] 55             push ebp
[000021bf] 8bec           mov ebp,esp
[000021c1] 689e210000     push 0000219e
[000021c6] e823f4ffff     call 000015ee
[000021cb] 83c404         add esp,+04
[000021ce] 50             push eax
[000021cf] 685f070000     push 0000075f
[000021d4] e8a5e5ffff     call 0000077e
[000021d9] 83c408         add esp,+08
[000021dc] 33c0           xor eax,eax
[000021de] 5d             pop ebp
[000021df] c3             ret
Size in bytes:(0034) [000021df]

  machine   stack     stack     machine        assembly >>>>>   address   address   data      code           language
  ========  ========  ========  ============== =============
[000021be][00103872][00000000] 55             push ebp
[000021bf][00103872][00000000] 8bec           mov ebp,esp
[000021c1][0010386e][0000219e] 689e210000     push 0000219e // push DDD
[000021c6][0010386a][000021cb] e823f4ffff     call 000015ee // call HHH
New slave_stack at:103916

Begin Local Halt Decider Simulation   Execution Trace Stored at:11391e >>>>> [0000219e][0011390e][00113912] 55             push ebp
[0000219f][0011390e][00113912] 8bec           mov ebp,esp
[000021a1][0011390a][0000219e] 689e210000     push 0000219e // push DDD
[000021a6][00113906][000021ab] e843f4ffff     call 000015ee // call HHH

The following shows the result of HHH emulating
itself emulating DDD. x86utm is a cooperative
multi-tasking operating system.

New slave_stack at:14e33e
[0000219e][0015e336][0015e33a] 55             push ebp
[0000219f][0015e336][0015e33a] 8bec           mov ebp,esp
[000021a1][0015e332][0000219e] 689e210000     push 0000219e // push DDD
[000021a6][0015e32e][000021ab] e843f4ffff     call 000015ee // call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[000021cb][00103872][00000000] 83c404         add esp,+04
[000021ce][0010386e][00000000] 50             push eax
[000021cf][0010386a][0000075f] 685f070000     push 0000075f
[000021d4][0010386a][0000075f] e8a5e5ffff     call 0000077e
Input_Halts = 0
[000021d9][00103872][00000000] 83c408         add esp,+08
[000021dc][00103872][00000000] 33c0           xor eax,eax
[000021de][00103876][00000018] 5d             pop ebp
[000021df][0010387a][00000000] c3             ret
Number of Instructions Executed(10069) == 150 Pages

Apparently you said that the last "ret" is not acutally emulated but
only its emulation is emulated.

Your trace lacks the indication of which lines are actually trace lines >>>> and which are output lines from the emulated program that only look like >>>> trace lines.

You must use the machine addresses to see what code
is being emulated. New slave_stack indicate that
a new process context has been created. Code following
that is being emulated.

Nowhere is said that a slave stack is disposed. Apparently no emulation
is ever completed. But your output is too defective to be sure.

New slave_stack at:14e33e indicates that HHH is
about to emulate itself emulating DDD.

But not to the completion of the emulated emulation.

When what is essentially infinite is specified
there is no transition to a final halt state.

True but not applicable to DDD, which is essentially finite if HHH
is a decider and uninteresting if HHH is not a decider.

--
Mikko

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