Re: HHH maps its input to the behavior specified by it --- never reaches its halt state

Op 09.aug.2024 om 17:04 schreef olcott:

On 8/9/2024 1:46 AM, Fred. Zwarts wrote:

Op 08.aug.2024 om 21:18 schreef olcott:

On 8/8/2024 2:04 PM, Fred. Zwarts wrote:

Op 08.aug.2024 om 20:48 schreef olcott:

On 8/8/2024 1:44 PM, Fred. Zwarts wrote:

Op 08.aug.2024 om 15:15 schreef olcott:

On 8/8/2024 3:24 AM, Fred. Zwarts wrote:

Op 07.aug.2024 om 15:01 schreef olcott:

On 8/7/2024 3:16 AM, Fred. Zwarts wrote:

Op 04.aug.2024 om 15:11 schreef olcott:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

>
Fortunately that is not what I try, because I understand that HHH cannot possibly simulate itself correctly.
>

>
void DDD()
{
   HHH(DDD);
   return;
}
>
In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?
>

>
Is English too difficult for you. I said HHH cannot do it correctly.

>
*According to an incorrect criteria of correct*
You keep trying to get away with disagreeing with
the semantics of the x86 language. *That is not allowed*
>

Again accusations without evidence.
We proved that HHH deviated from the semantics of the x86 language by skipping the last few instructions of a halting program.

>
void DDD()
{
   HHH(DDD);
   return;
}
>
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
>
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*

>
Indeed. And this correctly proves that the simulation failed, not because of an instruction simulated incorrectly, but because instructions are skipped.

>
void Infinite_Recursion()
{
   Infinite_Recursion();
   return;
}

>
Dreaming again of an infinite recursion?
>

>
The return instruction in both cases is unreachable code.
DDD correctly emulated by HHH and Infinite_Recursion
correctly emulated by HHH cannot reach the "return"
instruction.

>
It cannot reach it, because it was programmed to abort one cycle before the program would end.
>

>
*Maybe you have ADD like Richard has. I already said this above*
When zero to infinity steps of DDD are correctly emulated by
HHH no DDD ever reaches its own "return" instruction.
>
Maybe the issue is that you don't know programming well enough
to understand that this is true.

>
Maybe you should try to learn English. I confirmed hat HHH cannot reach the end of the simulation of itself.

 Yes and cups of coffee are made from ground coffee beans.
Changing the subject is merely the dishonest dodge of the
strawman deception.

So, why do you do it?

 

Maybe you should learn to program. When the simulation of a halting program is unable to reach the end, it proves that the simulation is incorrect.

  void Infinite_Loop()
{
   HERE: goto HERE;
}
 The correct simulation of the above never halts.

Again a change of subject. We are talking about a halting program, which looks more like:
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
In the case of the HHH for which you have published a 'trace', we see that it halts after two recursions, not after infinite recursions.
Therefore, who is dishonest to change the subject to an infinite recursion? Who is using the straw-man deception? It is the one who claims that two equals infinity!

 

Everybody with sufficient programming knowledge understands that a simulator cannot possibly simulate itself correctly up to the end, because either it does not halt, or it misses the last cycle, the final part of the simulation.

 When a simulating termination analyzer is essentially called
in infinite recursion it is smart enough to abort.
 

Apparently, your decider is unable to correctly recognise an infinite recursion. It incorrectly thinks that N equals infinity.
A good programmer should know the difference between two and infinity.
We are not dreaming of the HHH that does not abort, but about the HHH that aborts. Dreams are no substitute for facts.
HHH is required to halt. So, when HHH aborts itself after N recursions, the simulated HHH has only one recursion to go.
So, it is correct to say that HHH cannot possibly simulate itself correctly up to the end.