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

Am Wed, 10 Jul 2024 09:17:55 -0500 schrieb 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:

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.

You said previously that it could be a correct simulation to abort that.

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.

It is certain that the simulation will terminate of its own accord.

--
Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
Objectively I am a genius.