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

Op 10.aug.2024 om 13:34 schreef olcott:

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

Op 09.aug.2024 om 22:53 schreef olcott:

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

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

>
void DDD()
{
   HHH(DDD);
   return;
}
>
Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions of DDD correctly.
Every expert in the C language sees that this emulated DDD
cannot possibly reaches its own "return" instruction halt state.

And you don't need to be an expert to see that this proves that all these simulations are incorrect.

 In other words you are trying to get away with the lie that
Richard has been persistently pushing:
 When N > 0 instructions of DDD are correctly emulated by HHH
then no instructions of DDD have been correctly emulated.
 

In other words, you believe that only the numbers zero and infinite exist.
If I say that N instructions is not enough, you think I say zero instructions are simulated correctly.
Your English is very poor.
What I say is:
We know that HHH is halting. It is a requirement, it is also shown when executed directly and it is also shown when it is correctly simulated by another simulator, like HHH1. We then see that the number of instructions to be simulated to reach the end is K. But HHH simulates only N instructions. It skips M=K-N instructions.
Maybe I should repeat, because your English is so poor. I do not say that N=0.
It is not the N instructions that are correctly simulated that makes the simulation incorrect, it is the M instructions that are not simulated at all that makes the simulation incorrect.
Olcott tries to keep the discussion going on the subject whether the simulation of N instructions is correct, or not. As if there is anyone with doubts about the correct simulation of the N instructions. But he keeps the discussion there, to avoid to discuss why the simulation aborts after N instructions. He says that he has criteria to detect non-halting behaviour, but he is very vague about these criteria.
He has only shown a few trivial examples in which these criteria seem to have the desired effect of detecting non-halting behaviour. But it is clear that a few examples do not tell how good the algorithm is. Even for a decider that always returns 1 we can find examples for which it is correct.
The discussion should be about this algorithm. But that cannot be done, because olcott does not reveal the algorithm. As usual, we see only claims that non-halting behaviour is detected, but no evidence that these claims are true.
Apart from the trivial examples, such as Infinite_loop and Infinite_Recursion, he says that the abort is necessary to avoid an infinite recursion. Another thing nobody denies, but he likes to bring it up again and again, as if it proves that the algorithm is correct.
It seems that he does not realise that when the code to abort is added to HHH, we can construct a new DDD that calls this new HHH that aborts. But he keeps dreaming of the HHH that does not abort.
But the input of the new DDD includes the new HHH that aborts and halts, so the only correct decision would be that it halts and there is no reason to abort *this* input. (That does not mean that the HHH that does not abort, still needs to be aborted, but that is another input.)
The discussion should target the criteria to detect non-halting behaviour, but I am afraid olcott will not tell any details about them, because the halting theorem already proved that no such criteria exist that are always correct. Olcott probably knows that, if he would reveal details, therefore, immediately errors in his criteria will be spotted, so he needs to hide these criteria and avoid a discussion about them, in order to keep the discussion going.