Re: Indirect Reference Changes the Behavior of DDD() relative to DDD emulated by HHH

On 9/5/2024 9:34 AM, joes wrote:

Am Thu, 05 Sep 2024 08:48:24 -0500 schrieb olcott:

On 9/5/2024 5:04 AM, Fred. Zwarts wrote:

Op 04.sep.2024 om 14:37 schreef olcott:

On 9/4/2024 3:19 AM, joes wrote:

Am Mon, 02 Sep 2024 08:42:56 -0500 schrieb olcott:

On 9/1/2024 5:48 AM, Fred. Zwarts wrote:

Op 31.aug.2024 om 18:15 schreef olcott:

On 8/31/2024 10:47 AM, Fred. Zwarts wrote:

Op 31.aug.2024 om 17:22 schreef olcott:

On 8/31/2024 10:15 AM, Fred. Zwarts wrote:

Op 31.aug.2024 om 14:50 schreef olcott:

On 8/30/2024 8:31 AM, Mikko wrote:

On 2024-08-29 14:04:05 +0000, olcott said:

On 8/29/2024 3:00 AM, Mikko wrote:

On 2024-08-28 11:46:58 +0000, olcott said:

 

The direct execution of DDD includes the behavior of the
emulated DDD after it has been aborted.

And the simulator should also simulate until it sees the
behaviour of after the simulated HHH has aborted its simulator.

People that are not as stupid can see that HHH cannot wait for
itself to abort its own simulation.

And people (except the stupid ones) can see that, because HHH
cannot wait for itself,

Because this would require it to wait forever,
thus HHH knows that to meet its own requirement to halt it must
abort its simulation.

And because HHH is simulating itself, the simulated HHH also aborts.

It can not possibly do this. The outermost directly executed HHH
always sees the abort criteria before the next inner HHH sees it.
The abort criteria is that HHH sees the DDD has been emulated twice in
sequence.
When the outer HHH sees that itself and its emulated HHH has emulated
DDD once the emulated HHH only sees that itself has emulated DDD once.

Indeed. A very good explanation. That is what I told you many times.
The outer HHH fails to see that the inner HHH would abort as well,

IT WOULD NOT ABORT AS WELL. YOU HAVE THE FACTS INCORRECTLY.

The input to HHH calls that same HHH.
 

HHH MUST ABORT AFTER SOME FIXED NUMBER OF RECURSIVE EMULATIONS AND THE
OUTERMOST HHH ALWAYS SEE ONE MORE THAN THE NEXT INNER ONE.

If the outermost didn’t abort, the next one would.
You can test this by setting Root to a small integer and aborting
when it is less than zero (decrementing per simulation level).
I would also be interested in flipping the condition, so that only
the outermost level did NOT abort. Or maybe a boolean Root being
flipped in each recursion.
 

If we have an infinite chain of people each waiting for the next one
down the line to do something then that thing is never done.

If we have an infinite chain of people all interrupting each other,
nothing gets done either.

If we have an infinite chain of people each waiting for the next one
down the line to do something then that thing is never done.
If we have an infinite chain of HHH emulating DDD that calls
HHH that emulates DDD and each HHH waits for the next one to
abort its emulation then no emulation is ever aborted.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer