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

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.

 If you don't know the first thing about programming you
might not notice this.
 

You forget that I know that HHH cannot reach its end, because it was aborted too soon.
As an experienced programmer I know that aborting a halting program too soon causes it to not reach its end.
It seems that you do not know that.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
When Finite_Recursion needs 10 recursions and it is aborted after two recursions, it does not reach its end. That does not prove that it is a non-halting program. It proves that the abort came too soon.
Similarly, when HHH needs two cycles, but its simulation is aborted after one cycle, it only shows that the abort came too soon.
It does not help to dream of a HHH that does not abort. Dreams are no substitute for facts.
HHH cannot possibly simulate itself correctly, because it cannot reach its end.