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

Op 09.aug.2024 om 18:19 schreef olcott:

On 8/9/2024 10:27 AM, Fred. Zwarts wrote:

Op 09.aug.2024 om 15:41 schreef olcott:

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

Op 09.aug.2024 om 05:03 schreef olcott:

On 8/8/2024 9:52 PM, Richard Damon wrote:

On 8/8/24 9:15 AM, olcott wrote:

>
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*
>
There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.
>
Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.
>
>

>
Nope, it is a lie based on comfusing the behavior of DDD which is what "Halting" is.
>

>
Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.
>
You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.
>
*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.

There is no correct simulation of HHH by itself. HHH cannot possibly simulate itself correctly. A correct simulation of a halting program must reach this state.

>
Try and show how it is incorrect.

We proved it many times, but it seems you do not understand it. It is unclear to me whether you are unable to understand it or unwilling to understand it. But I will go another mile.
>
(HHH is required to halt, so we don't need to consider the non- aborting HHH.)
1) HHH is programmed to abort after N cycles. When HHH simulates itself, the simulating HHH aborts after N cycles.

 That is false. AKA counter-factual.

Your own words were that HHH is a halting decider. You even showed traces of HHH aborting after two cycles. Are you short of memory, or are you lying? Or are you again substituting your dreams of a non-aborting non-halting HHH for facts?

 

2) Note, we are looking at the HHH that aborts after N cycles, not the one that does not abort. Both the simulating and the simulated HHH use the same algorithm, namely, the algorithm to abort after N cycles.

 When we look at every HHH that can possibly exist then we
see that DDD correctly emulated by each one of these cannot
possibly reach its own "return" instruction halt state.

There is no HHH that can correctly simulate DDD, because DDD includes HHH and HHH cannot possibly simulate itself correctly. So, your 'every HHH' is an empty set.
But leaving out 'correctly', that is exactly what I said, but you removed it. This correctly proves that the simulation is incomplete and, therefore, incomplete. A correct simulation would simulate the halting program up to the end, as is shown when HHH is simulated by HHH1.
It does not help to repeat the same error again, it does not become correct by just repetition.

 That you can't understand this seems to indicate a lack
of software engineering skills.
 

Irrelevant ad hominem attack ignored. It only shows a lack of reasoning.