Re: Hypothetical possibilities

Am Sun, 21 Jul 2024 18:42:26 +0200 schrieb Fred. Zwarts:

Op 21.jul.2024 om 16:25 schreef olcott:

On 7/21/2024 5:25 AM, Fred. Zwarts wrote:

Op 20.jul.2024 om 22:08 schreef olcott:

On 7/20/2024 3:03 PM, Alan Mackenzie wrote:

In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:
>

Olcott could not point to an error, but prefers to ignore it. So, I
will repeat it, until either an error is found, or olcott admits
that HHH cannot possibly simulate itself correctly.

>
This has the disadvantage of making your posts boring to read.  All
but one poster on this newsgroup KNOW that Olcott is wrong, here.
Continually repeating your argument won't get him to admit he's
wrong. Richard has been trying that for much longer than you have,
with the same lack of success.  Olcott's lack of capacity for
abstract reasoning,
combined with his ignorance, combined with his arrogance, prevent
him learning at all.
May I suggest that you reconsider your strategy of endless
repetition?

Yes. It is as spammy as olcott themselves, or Richard for that matter.

As long as the x86 machine language instructions of DDD are emulated by
HHH according to the semantic meaning of these instructions then the
emulation is correct and anyone that disagrees is disagreeing with a
tautology.

But if some x86 instructions are skipped, then it is dishonest to say
that it is a correct simulation. If the last cycle of HHH, after which
it would halt, is skipped by the simulation, then the simulation is
incorrect.
It is dishonest to deny that skipping instructions is correct according
to the semantics of the x86 language.

Well put

This correct emulation must take into account the fact that DDD is
calling its own emulator: HHH(DDD) in recursive emulation.

And since HHH cannot possibly simulate itself correctly, the simulation
of DDD is incorrect.
DDD is a misleading and unneeded complication. It is easy to eliminate
DDD:
        int main() {
          return HHH(main);
        }
This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.

Yes. Why does HHH think it doesn't halt, when it makes damn sure to halt?

HHH is simply unable to decide about finite recursions.
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
It decides after N recursions that there is an infinite recursion, which
is incorrect.

Do you agree with this analysis?

Olcott does not know how to point to an error in this explanation, but
prefers to ignore it. He even consistently removes it from the
citations. So, I will repeat it, until either an error is found, or
olcott admits that HHH cannot possibly simulate itself correctly.

WONTFIX

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.