Re: Liar detector: Fred, Richard, Joes and Alan

Op 05.jul.2024 om 14:43 schreef olcott:

On 7/5/2024 7:26 AM, joes wrote:

Am Fri, 05 Jul 2024 07:20:04 -0500 schrieb olcott:

On 7/5/2024 4:49 AM, joes wrote:

Am Wed, 03 Jul 2024 13:57:40 -0500 schrieb olcott:

On 7/3/2024 1:40 PM, Fred. Zwarts wrote:

Op 03.jul.2024 om 20:20 schreef olcott:

>

DDD correctly emulated by any element of the infinite set of every
pure function HHH cannot possibly reach its own ret instruction and
halt. That HHH aborts its emulation at some point or never aborts
its emulation cannot possibly change this.
>

Ad hominem attacks always try to hide a lack of argumentation.
It has been proved that HHH cannot possibly correctly simulate
itself.

>
That is false and you know it. That might not be a flat out lie as it
is an sloppy use of language.
>
HHH does correctly simulate itself simulating DDD one time, then it
stops correctly simulating itself because this criteria is met:
       HHH correctly simulates its input DDD until HHH correctly
       determines that its simulated DDD would never stop running
       unless aborted

But it would stop running.

Not if not aborted.

But it is aborted!
>

 *It is not aborted when HHH makes its decision to abort*
It is a fact that HHH must abort the simulation of its
input to prevent its own infinite execution.

Incorrect! The input already aborts and halts, so the simulator does not need to abort. However, HHH cannot possibly correctly simulate itself, because it is programmed to abort prematurely.

 At the point in the execution trace of DDD correctly
emulated by HHH where it knows that it must abort HHH
has correctly determined that DDD is non-halting.

It incorrectly did it. DDD is not non-halting, because DDD would return if not aborted, because the HHH on which it is based would abort and return. So, the simulator prematurely decided to abort and halt.

 Every time that HHH must abort the emulation of ANY input
to prevent its own infinite execution HHH is always correct
to do this and reject this input as non-halting

But in this case there is no need to prevent an infinite recursion, because the simulated HHH already aborts and halts, so, there is no infinite recursion.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
There is only an infinite recursion when you are dreaming of an HHH that does not abort, but such dreams are irrelevant, because the HHH we are talking about, *does* abort.

 The above is a tautology.
 

This tautology does not apply, because the assumptions are false.