On 2/8/2025 3:57 AM, Fred. Zwarts
Op 08.feb.2025 om 06:53 schreef
On 2/7/2025 7:27 PM, Richard Damon
On 2/7/2025 5:56 PM, Richard
On 2/7/2025 6:20 AM, Richard
On 2/6/25 10:02 PM, olcott
On 2/6/2025 8:21 PM, Richard
On 2/6/25 5:18 PM, olcott
On 2/6/2025 1:51 PM,
On 2/6/25 1:26 PM, olcott
On 2/6/2025 10:52 AM,
Bonita Montero
Which proves that HHH fails to make a
correct
decision about DD's halting
behaviour. All other
methods (direct execution,
simulation by a world class
simulator, etc.) show
that DD halts. But HHH fails to see
it. Everyone with
sufficient understanding of
programming sees that HHH
is not correctly programmed when it
aborts one cycle
before the simulation would end
normally.
The execution trace only shows that HHH
is unable to
complete its simulation, because HHH is
unable to
simulate itself.
It turns out that Olcott does not even
understand this
simple proof that HHH produces false
negatives. HHH is
unable to simulate itself up to the
normal termination.
So, in other words, Olcott denies verified
facts.
HHH generates false negatives, as is
verified in
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple
verified facts, which
he tries to hide with a lot of irrelevant
words.
It is a verified fact that main cannot
possibly be correctly
simulated by HHH until its normal termination.
Indeed, which proves that HHH is unable to
simulate itself
correctly.
If this was true then you could point out
exactly where HHH is
incorrect.
HHH is supposed to be a decider, i.e. halt and
return the
correct value.
The directly executed HHH(DD) always halts and
returns a correct
value as soon as it correctly determines that
its input cannot
possibly terminate normally.
We were talking about HHH(HHH). If the outer HHH
halts according
to spec, so does the inner, because it is the
same. Therefore it
can’t report „non-halting” and be correct. If the
inner HHH
doesn’t halt, it is not a decider.
I am not going to ever talk about that.
Oh goody, you’re never getting anywhere if you reject
corrections.
I reject infinite deflection away from the point. The
absolute
single-mined focus point is that DD correctly simulated
by HHH cannot
possible terminate normally.
That IS the point. DD does nothing else than call HHH.
Since there is a 5% chance that the treatment I will
have next month
will kill me and this treatment is my only good chance I
will totally
ignore anything that diverges from the point.
Ok, I will wait a month then.
Anyone that knows the C language sufficiently well knows
that DD correctly simulated by HHH cannot possibly
terminate normally.
Indeed, which shows the limitation of HHH which makes that
it cannot properly decide about its input, because it must
abort the correct simulation before it sees that the
correct simulation terminates normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
If I close my eyes, so that I do not see the accident, I
cannot claim that the accident did not happen. That is the
reasoning of a 2 years old child.
HHH(DD) maps the finite string input of DD to the behavior
that it specifies. This behavior does include DD repeatedly
calling HHH(DD)
in recursive simulation that that cannot possibly terminate
normally.
Olcott is again dreaming of a HHH that does not abort. Dreams
are no substitute for reasoning.
The simulating HHH aborts the simulation, closes its eyes and
does not see that the simulated HHH also aborts so that the
program terminates normally.
It is only your lack of technical competence that makes it seem
that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
Which does not change the fact that simulating HHH does not see
that the simulated HHH would also abort,
The simulated HHH cannot possibly abort because it can't possibly
get to the point where it sees that it needs to abort because it
is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point where the
simulated HHH aborts and halts. The simulating misses in this way
relevant details of the program given in its input. That is the
reason why it fails. It is unable to see the whole input, because
it gets stuck in recursive simulation of itself.
This is all moot because the executed HHH recognizes this
pattern and correctly reports that its input cannot possibly
terminate normally.
It only reports that the simulation was aborted. Not more, not less.
That you do not understand the term: "terminates normally"
is far less than no rebuttal at all.
So we (Olcott and me) agree that HHH cannot possibly simulate up to the
normal termination of the program described by the finite string.
Good.
However, Olcott fails to see that it is a failure of HHH to be unable to
simulate a halting program up to the end.
What most everyone fails to understand is that the inability to
accomplish the logically impossible is never any actual sort of failure.
In his citation he deleted my suggestion to change his simulator.
To the best of my knowledge any change would be erroneous.
Instead of aborting the simulation at the call to HHH, he could replace
this call with the correct return value of HHH
If you understand this code then you can see that this is is not what
the code itself specifies.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
HHH[0] simulates DD[0]
that calls HHH[1] on its line 1 to simulate DD[1]
that calls HHH[2] on its line 1 to simulate DD[2]
that calls HHH[3] on its line 1 to simulate DD[3]...
(which he seems to know)
and then continue the simulation of DD. This avoids the recursion
introduced by the simulator.
We cannot simply ignore the call to HHH(DD) from DD
and replace this call with different code and construe
this as a correct simulation.
*Here is what you seem to be saying, HHH changes this code*
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*To this code*
int DD()
{
return 1;
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer