Re: Sequence of sequence, selection and iteration matters

Op 12.jul.2024 om 15:45 schreef olcott:

On 7/12/2024 7:53 AM, Fred. Zwarts wrote:

Op 12.jul.2024 om 14:33 schreef olcott:

>
There is no freaking end you freaking moron.
I apologize for getting harsh, yet nothing else seems to work.
>

>
I don't feel offended, because I know you have problems to recognize the truth.
You think that by only wishing and repeating you can make something true.
>
Each HHH that aborts has an end,

 Maybe you don't understand what halting means.
When DDD correctly emulated by HHH stops running because
HHH correctly recognizes that DDD would never otherwise
stop running THIS DOES NOT MEAN THAT DDD HALTS.

But HHH is wrong in this determination, because one cycle later its simulation would halt without a need to abort, because the simulated HHH would abort.

 _DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
 

We are talking about an HHH that is programmed to abort after N cycles (with N = 0 up to an arbitrary large number ∞). Each of them aborts one cycle before the simulated HHH would abort. It makes no sense to dream about another HHH that does not abort, because we are considering the case of an HHH that aborts.
This shows that each HHH aborts the simulation of itself prematurely. Therefore, each HHH has an end (that is how it is programmed), but the simulation does not reach it.
Therefore, each of these simulations is incorrect.
No matter how much you want to be it correct, or how many times you repeat that its is correct, it does not change the fact that the simulation is incorrect, because it is unable to reach the end.
DDD has nothing to do with it. It is easy to eliminate DDD:
        int main() {
          return HHH(main);
        }
This has the same problem. Proving that the problem is not in DDD, but in HHH, which is required to halt, but it decides that HHH does not halt.
HHH is unable to decide about finite recursions.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
It decides after N recursions that there is an infinite recursion, which is incorrect.