Re: Flat out dishonest or totally ignorant? --- Richard seems to be willfully ignorant

Op 03.jul.2024 om 18:11 schreef olcott:

On 7/3/2024 11:05 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 17:53 schreef olcott:

On 7/3/2024 10:44 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 15:22 schreef olcott:

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

Op 03.jul.2024 om 05:07 schreef olcott:

On 7/2/2024 9:35 PM, Richard Damon wrote:

On 7/2/24 10:03 PM, olcott wrote:

On 7/2/2024 8:51 PM, Richard Damon wrote:

On 7/2/24 9:32 PM, olcott wrote:

On 7/2/2024 8:25 PM, Richard Damon wrote:

On 7/2/24 9:18 PM, olcott wrote:
>

Professor Sipser probably does understand the x86 language.
Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf
>
>

And the x86 language says the same thing,
>
YOU are just a liar, as proved by the fact that you can not give the Diagonalization proof you claimed you had.
>
Sorry, you are just too stupid to understand.

>
You continue to assume that you can simply disagree
with the x86 language. My memory was refreshed that
called you stupid would be a sin according to Christ.
I really want to do the best I can to repent.
>

>
But I am NOT disagreeing with the x86 language.
>
Can you point out what fact of it I am disagreing about it?
>

>
You keep trying to get away with saying that the simulation is
incorrect when the semantics of the x86 language conclusively
proves that it is correct.

>
Nope, and x86n emulation is only fully correct if it continues to the final end.

>
void Infinite_Loop()
{
   HERE: goto HERE;
}
>
Why do you say such ridiculously stupid things that you are are false?
>

>
Your Infinite_Loop does not apply. For a two cycle recursive simulation
>

>
This says nothing about two cycles nitwit.
>
_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
>
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
>
>

>
You told us that HHH aborts its simulation after two cycles.

>
The above HHH refers to every pure function that correctly
emulates one of more steps of DDD.
>

>
As long as there are a finite number of steps, there is no infinite recursion. The problem remains that HHH cannot simulate itself correctly.

  void Infinite_Loop()
{
   HERE: goto HERE;
}
 Likewise infinite loops are not infinite loops thus
contradicting the law of identity.
 

Bad example, although I know you think two equals infinite.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
You (and your simulator) will probably think Finite_Recursion is also an infinite recursion.