Re: DDD correctly emulated by HHH cannot possibly halt

Op 12.jul.2024 om 14:28 schreef olcott:

On 7/12/2024 6:15 AM, Richard Damon wrote:

On 7/11/24 11:30 PM, olcott wrote:

On 7/11/2024 10:18 PM, Richard Damon wrote:

On 7/11/24 10:28 PM, olcott wrote:

 We stipulate that the only measure of a correct emulation
is the semantics of the x86 programming language. By this
measure when 1 to ∞ steps of DDD are correctly emulated
by each pure function x86 emulator HHH (of the infinite
set of every HHH that can possibly exist) then DDD cannot
possibly reach its own machine address of 00002174 and halt.

Which proves that the simulation is incorrect.
A correct simulation is able to reach the end of a halting program.
To make a simulation correct and follow the semantics of the x86 language, it is incorrect to abort halfway a halting program.
So, your conclusion is not inline with the stipulation to use the semantics of the 86 language as a measure of a correct simulation.

 _DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
 

>
When 1,2,3... ∞ steps of DDD are correctly emulated by
HHH it is a lie to say that this many instructions were
not correctly emulated and you know it.
>

>
But only N instructions "correctly emulated" is NOT a CORRECT emulaition of the instructions of DDD/HHH
>

>
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
I didn't limit it to N. Is this your ADD? I say 1 to infinity steps !!!
>

>
So, I guess NONE of them ever stop before reaching the end, if none of them stop before that.
>

 1,2,3... ∞ steps of DDD are correctly emulated is every
HHH/DDD pair that can possibly exist when HHH is a pure
function x86 emulator.

When N steps (with N = 1,2,3, up to ∞ , meaning up to an arbitrary large number) are simulated and none of these simulations is correct, because they all abort one cycle too soon, then the conclusion must be that HHH cannot possibly simulate itself correctly up to the end. None of them is able to use the semantics of the X86 language correctly, because that semantics does not require an abort for a halting program.
(We see that other simulators can simulate HHH up to the end, but HHH cannot simulate *itself* up to the end.)
This is definitely not a problem of DDD, but of HHH, because without DDD, such as in:
        int main()
        {
          return HHH(main);
        }
We see the same problem.
The problem is that HHH is unable to see the difference between a finite and an infinite recursion.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
HHH decides that any recursion with more than two cycles is an infinite recursion.
But two cycles are not the same as an infinite number of cycles.
Sipser would agree that a simulation that aborts halfway its simulation is incorrect.