Re: Hypothetical possibilities --- Fake rebuttals trying to get away with mere rhetoric --- Dishonest reviews that ignore what I say

Op 23.jul.2024 om 20:12 schreef olcott:

On 7/23/2024 12:38 PM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 7/23/2024 2:26 AM, Mikko wrote:

On 2024-07-22 16:10:55 +0000, olcott said:

>

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

[ Followup-To: set ]

>

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?

>

Thanks!

>
>
>

Rebuttals like yours are entirely baseless by failing to point out any
mistake.

>

What makes you think taht Alan Mackenzie was trying to rebut what
Fred. Zwarts had said?

>
>

In other words you don't see the ad hominem attacks against
me that are listed above?

>
What, exactly, is wrong with what you call my "ad hominem attacks"?  In
most of what you write on this group you are objectively wrong,

 *No as many as one person ever actually showed that*
 void DDD()
{
   HHH(DDD);
}
 int main()
{
   HHH(DDD);
}
 Of the two hypothetical possible ways that HHH can be encoded:
(a) HHH(DDD) is encoded to abort its simulation at some point.
(b) HHH(DDD) is encoded to never abort its simulation.
 We can know that (b) is wrong because this fails to meet the design requirement that HHH must itself halt.

We also know that (a) is wrong, because it aborts too soon, when the simulation of itself has still one cycle to go. This makes the simulation incomplete and therefore incorrect. It also fails the design requirement that its simulation must be correct.
So, both hypothetical ways are wrong. There is no correct way.
HHH cannot possibly simulate itself correctly.
This has been pointed out to you many times, but you ignore it and keep saying that no as many as one person ever actually showed that.

 For example I have proved that my point is correct recently
to you several times and you make sure to not even look at
it on the basis that you baselessly assume that I did not
change my words to make them more clear.

Many people looked at it and found many errors, but you ignore them and keep saying that no as many as one person ever actually showed that.

 There are more key details that I did not provide so
that you do not get overwhelmed and ignore everything
that I say.
 

and you
simply ignore other people's arguments that establish that fact.  You
repeat falsehood after falsehood here, and don't do it in a polite
fashion, either.
>

 Whenever any rebuttal is based on a provably false assumption
I stop reading it.

But when other people do that with your contributions, you start to complain that not enough attention was paid to it.

 

You ignore rational argument, and repeat your falsehoods many hundreds of
times.  You lack the capacity for abstract reasoning, as has been pointed
out several times by several people, most notably by Mike Terry.  You are
arrogant, in that you believe yourself to be a genius, without any
supporting evidence.  You are ignorant of the foundations of mathematical
logic, and your arrogance prevents you learning it.
>

 Mike Terry is the most competent and accurate reviewer
yet even he makes sure to simply ignore key points that
I make and leaps to the conclusion that I must be wrong
without even carefully seeing what I am actually saying.
 He only does this on one key issue, every other aspect
of his review seems to be accurate.
 Message-ID: <rLmcnQQ3-N_tvH_4nZ2dnZfqnPGdnZ2d@brightview.co.uk>
On 3/1/2024 12:41 PM, Mike Terry wrote:
 >
 > Obviously a simulator has access to the internal state
 > (tape contents etc.) of the simulated machine. No problem there.
 Mike and I could never go to closure on the details of how
this can be implemented because he begins this discussion
with the certainty that I am wrong about this issue thus
will not discuss it. Other than that Mike's reviews seem
to be accurate.
 I implementing the above with a way for the simulated
instances to pass their execution trace up to the master
simulator and Mike persistently believed that this was the
master simulator passing information down to the slaves.
 Every rebuttal of my work has been specifically counter-factual.

Only because you twist the meaning of 'fact', because you could not present any fact to be counter.
You did not present facts, only false claims.
When errors are pointed out, you ignore them and keep repeating those false claims.
E.g., you could never find an error in the following, but you keep ignoring it.
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.
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.
Olcott's HHH is programmed to abort the simulation after N cycles of recursive simulations. Therefore, it is incorrect to abort the simulation of HHH when the simulated HHH has performed only N-1 cycles, because that changes the behaviour of HHH.
Since the simulated HHH always runs one cycle behind the simulating HHH, it is clear that HHH can never simulate enough cycles for a correct simulation, as is required by the x86 language.
Therefore, the simulation is incorrect according to the criteria olcott stipulated.
The conclusion is simple:
HHH cannot possibly simulate itself correctly.
No matter how much olcott wants it to be correct, or how many times olcott repeats that it is correct, it does not change the fact that such a simulation is incorrect, because it is unable to reach the end.
Olcott's own claim that the simulated HHH does not reach its end confirms it. The trace he has shown also proves that HHH cannot reach the end of its own simulation. So, his own claims prove that it is true that HHH cannot possibly simulate itself up to the end, which makes the simulation incorrect.
Sipser would agree that this incorrect simulation cannot be used to detect a non-halting behaviour.