Re: Hypothetical possibilities --- Correct emulation has been proven for three years

Op 01.aug.2024 om 13:28 schreef olcott:

On 8/1/2024 2:20 AM, joes wrote:

Am Wed, 31 Jul 2024 16:23:09 -0500 schrieb olcott:

On 7/31/2024 3:01 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 17:14 schreef olcott:

On 7/31/2024 3:44 AM, Fred. Zwarts wrote:

Op 31.jul.2024 om 06:09 schreef olcott:

>

We don't show any of HHH and show the execution trace of of just DDD
assuming that HHH is an x86 emulator.

This assumption is incorrect if it means that HHH is an unconditional
simulator that does not abort.

This algorithm is used by all the simulating termination analyzers:

>

So, Sipser only agreed to a correct simulation, not with an incorrect
simulation that violates the semantics of the x86 language by skipping
the last few instructions of a halting program.
>

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}
int main()
{
    HHH(DD);
}
DD correctly emulated by HHH cannot possibly reach its own second line.

If HHH can't simulate itself, it is not a decider.
>

 So we are back to your lack of software engineering skill.

Don't talk about software skill, when you do not even understand the software written by yourself.

You cannot see that the second instruction of DD correctly*
emulated by HHH cannot possibly be reached by DD. This
remains true no matter how many levels that HHH emulates
itself emulating DD.

Which only shows that the simulation of HHH by itself is incorrect.
Other simulators (such as HHH1) have problem to do it, proving that the problem is in HHH.

 *According to the x86 semantics of DD and HHH
 

You are running in circles of not understanding the semantics of x86.
HHH simulates only the first few instructions and then skips the last few instructions of HHH. Skipping instructions of a halting program (HHH) violates the semantics of x86. Even when the first few instructions are simulated correctly.
The problem is that HHH cannot possibly simulate itself correctly.
Therefore, it cannot reach the return of the simulated HHH.
A correct simulation of HHH (e.g. by HHH1) shows that the simulation of HHH can reach its end and then return to DD.
It is incorrect to blame DD for it, because the same problem is also present in
        int main() {
          return HHH(main);
        }
This has been told to you many times, but it seems that you are unable to learn.