On 2024-08-17 12:29:15 +0000, olcott said:

void DDD()
{
HHH(DDD);
}

_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]

*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)

It is obfious from both the C code and disassembly listing
that DDD cannot return if HHH doesn't (but can and does
otherwise). Whether HHH returns is not obvious as the details
of HHH is not shown and most of its behaviour is unspecified.

The phrase "DDD emulated by HHH" is not good. It may be even
misleading. DDD is fully specified by the code above except
the effect of calling HHH, so the phrase "emulated by HHH"
does not mean anything.

Because of these defects one can truthfully disagree. In addition
disagreement about anyithing other than facts can be truthful
anyway. Therefore the claim on the subject line is false.

--
Mikko

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

On 2024-08-17 12:31:01 +0000, olcott said:

On 8/17/2024 7:29 AM, olcott wrote:

void DDD()
{
  HHH(DDD);
}

_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]

*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)

Simulating Termination Analyzer H is Not Fooled by Pathological Input D

https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

That attempt should be discussed separately, and to some extent already is.

--
Mikko

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

On 8/18/24 8:25 AM, olcott wrote:

On 8/18/2024 3:49 AM, Mikko wrote:

On 2024-08-17 12:29:15 +0000, olcott said:

void DDD()
{
   HHH(DDD);
}

_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]

*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)

It is obfious from both the C code and disassembly listing
that DDD cannot return if HHH doesn't (but can and does
otherwise). Whether HHH returns is not obvious as the details
of HHH is not shown and most of its behaviour is unspecified.

That HHH <is> and x86 emulator <is> sufficient to
determine exactly what the behavior of DDD emulated by HHH
according to the semantics of the x86 language would be.

And that is that DDD will halt if, and only if, HHH aborts its
simulation and returns to its caller.

That you don't want to accept that if the HHH that we are asking, which
is also the HHH that DDD is calling does abort, that HHH can't use the
behavior of the DDD that calls the HHH that doesn't abort in its
analysis, since that isn't the HHH that DDD calls. This means that HHH
is NOT correct to abort and decide non-halting.

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

On 2024-08-18 12:25:05 +0000, olcott said:

On 8/18/2024 3:49 AM, Mikko wrote:

On 2024-08-17 12:29:15 +0000, olcott said:

void DDD()
{
   HHH(DDD);
}

_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]

*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)

It is obfious from both the C code and disassembly listing
that DDD cannot return if HHH doesn't (but can and does
otherwise). Whether HHH returns is not obvious as the details
of HHH is not shown and most of its behaviour is unspecified.

That HHH <is> and x86 emulator <is> sufficient to
determine exactly what the behavior of DDD emulated by HHH
according to the semantics of the x86 language would be.

The last "would be" means that the clause is conterfactual.
But why would anybody care about the conterfactual behaviour?

--
Mikko

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

Op 17.aug.2024 om 14:29 schreef olcott:

void DDD()
{
  HHH(DDD);
}

_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]

*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)

Which proves that the simulation failed to reach the end. This makes the simulation incomplete and therefore incorrect.
The simulating HHH is programmed to abort and halt. The simulated HHH
should behave exactly in the same way, so no cheating with the Root
variable is allowed.
The the simulating HHH aborts when the simulated HHH has only one cycle
to go, after which it would also abort and halt, but the simulating HHH
failed to reach this end.

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

On 2024-08-18 12:25:05 +0000, olcott said:

On 8/18/2024 3:49 AM, Mikko wrote:

On 2024-08-17 12:29:15 +0000, olcott said:

void DDD()
{
   HHH(DDD);
}

_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]

*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)

It is obfious from both the C code and disassembly listing
that DDD cannot return if HHH doesn't (but can and does
otherwise). Whether HHH returns is not obvious as the details
of HHH is not shown and most of its behaviour is unspecified.

That HHH <is> and x86 emulator <is> sufficient to
determine exactly what the behavior of DDD emulated by HHH
according to the semantics of the x86 language would be.

If HHH is merely an x86 emulator then obviously HHH(DDD) does not
return (instead it crashes for trying to use too much memory) and
therefore DDD does not return, either.

--
Mikko

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