Re: Flat out dishonest or totally ignorant?

Am Thu, 04 Jul 2024 11:24:45 -0500 schrieb olcott:

On 7/4/2024 11:22 AM, joes wrote:

Am Thu, 04 Jul 2024 10:56:10 -0500 schrieb olcott:

On 7/4/2024 10:07 AM, joes wrote:

Am Thu, 04 Jul 2024 08:43:22 -0500 schrieb olcott:

On 7/4/2024 8:38 AM, joes wrote:

Am Thu, 04 Jul 2024 07:50:51 -0500 schrieb olcott:

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

Am Wed, 03 Jul 2024 11:21:01 -0500 schrieb olcott:

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

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

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

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

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

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

On 7/2/2024 10:50 PM, joes wrote:

Am Tue, 02 Jul 2024 14:46:38 -0500 schrieb olcott:

On 7/2/2024 2:17 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 21:00 schreef olcott:

On 7/2/2024 1:42 PM, Fred. Zwarts wrote:

Op 02.jul.2024 om 14:22 schreef olcott:

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

Op 02.jul.2024 om 03:25 schreef olcott:

>

Similarly, if you think that HHH can simulate itself
correctly,
you are wrong.
            int H(ptr p, ptr i);
            int main()
            {
              return H(main, 0);
            }
You showed that H returns, but that the simulation thinks it
does not return.
DDD is making it unnecessarily complex, but has the same
problem.

main correctly emulated by H never stops running unless
aborted.

HHH is unable to simulate main correctly, because it unable to
simulate itself correctly.
The 'unless phrase' is misleading, because we are talking about
a H *does* abort. Dreaming of one that does not abort, is
irrelevant. The correctly simulated main would stop, because
the simulated H is only one cycle away from its return when its
simulation is aborted.

HHH is required to report on what would happen if HHH did not
abort.
HHH is forbidden from getting its own self stuck in infinite
execution. Emulated instances of itself is not its actual self.

No. HHH is simulating itself, not a different function that does
not abort. All calls are instances of the same code with the same
parameters. They all do the same thing: aborting.

HHH always meets its abort criteria first because it always sees
at least one fully execution trace of DDD before the next inner
one. It is stupidly incorrect to think that HHH can wait on the
next one.

Stupidly incorrect is thinking that the next one wouldn’t abort
just because that part isn’t simulated.

Unless the outermost one aborts none of them do.

Since the outermost aborts, all of them do.

The inner ones ARE abortED, which prevents THEM from aborting.

They all use the exact same code.
The outer one meets its abort criteria first.

The inner ones have the same criterion.

This means unless the outer one aborts NONE OF THEM ABORT.

Only because that is not simulated yet. That doesn’t mean that they
run forever.

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