Re: Liar detector: Fred, Richard, Joes and Alan --- Ben's agreement

Op 10.jul.2024 om 16:17 schreef olcott:

On 7/10/2024 9:11 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 15:37 schreef olcott:

On 7/10/2024 2:18 AM, Mikko wrote:

On 2024-07-09 14:14:16 +0000, olcott said:
>

On 7/9/2024 1:14 AM, Mikko wrote:

On 2024-07-08 17:36:58 +0000, olcott said:
>

On 7/8/2024 11:16 AM, Fred. Zwarts wrote:

Op 08.jul.2024 om 18:07 schreef olcott:

>
Try to show how infinity is one cycle too soon.
>

You believe that two equals infinity.

>
void Infinite_Loop()
{
   HERE: goto HERE;
}
>
void Infinite_Recursion()
{
   Infinite_Recursion();
}
>
void DDD()
{
   HHH(DDD);
}
>
Two cycles is enough to correctly determine that none
of the above functions correctly emulated by HHH can
possibly halt.
>
That you don't see this is ignorance or deception.

>
There is an important detail that determines whether an infinite
execution can be inferred. That is best illustrated by the following
examples:
>
void Finite_Loop()
{
  int x = 10000;
HERE:
  if (x > 0) {
    x--;
    goto HERE;
  }
}
>
void Finite_Recursion(int n)
{
  if (n > 0) {
    Finite_Recursion(n + 1);
  }
}
>
void DDD()
{
  HHH(DDD); // HHH detects recursive simulation and then simulates no more
}
>
The important difference is that in my examples there is a conditional
instruction that can (and does) prevent infinite exectuion.
>

>
When we ask:
Does the call from DDD emulated by HHH to HHH(DDD) return?

>
Why would anyone ask that? A question should make clear its topic.
Instead one could ask whether HHH can fully emulate DDD if that is
what one wants to know. Or one may think that HHH and DDD are so
unimteresting that there is no point to ask anyting about them.
>

>
A correct emulator can correctly any correct x86 instructions.
When it emulates non-halting code then itself does not halt.
>

>
But when simulating a halting code, it is incorrect to abort the simulation halfway, even when you dream of another non-halting code. Such dreams are irrelevant.

 As soon as it is certain that not aborting results in
its own non-termination a simulating termination must
abort.
 

A program is not certain of something, it just does what it is programmed to do.
Simulating N cycles of recursion, when N+1 cycles are needed, shows that it aborted too soon.
Other simulators show that it is possible to simulate N+1 cycles, but HHH cannot do that.
Therefore, HHH cannot possibly simulate itself correctly, because it always aborts too soon.
Dreaming that it aborted an infinite recursion, does not change the fact that it aborted a finite recursion.
You only prove that it is not a clever idea to try to simulate a simulator by itself. It cannot possibly be correct.