Subject: Re: Kaz does not understand his own code. --- I AM PROVED EXACTLY CORRECT.

On 11/5/2025 11:35 AM, Kaz Kylheku wrote:

On 2025-11-05, olcott <polcott333@gmail.com> wrote:

On 11/5/2025 1:01 AM, Kaz Kylheku wrote:

On 2025-11-05, olcott <polcott333@gmail.com> wrote:

On 11/4/2025 8:43 PM, Kaz Kylheku wrote:

The whole point is that D simulated by H
cannot possibly reach its own simulated
"return" statement no matter what H does.

Yes; this doesn't happen while H is running.

*That is the definition of non-halting input*

Well, anyway, there you go; that's how the "D simulated by H" is the
same halting D as the directly executed one.

The whole point is that D simulated by H
cannot possibly reach its own simulated
"return" statement no matter what H does.

The semantic halting property of the input
to H(D) has been proven to be non-halting.

So you are saying that no simulating decider could ever be wrong about
its D-like diagonal input case, if it conducts an incomplete (but
otherwise correct) simulation of its input and then returns false for
any reason whatsoever (such as "if the input is taking more than three
steps, it must be nonterminating").

Boy is that an intentionally deceptive and moronically
stupid paraphrase of what I have been saying for years.
Here is the essence of what I am proposing some details
are left out because with too many details and people get
confused.


On 11/4/2025 8:43 PM, Kaz Kylheku wrote:

On 2025-11-05, olcott <polcott333@gmail.com> wrote:

The whole point is that D simulated by H
cannot possbly reach its own simulated
"return" statement no matter what H does.

Yes; this doesn't happen while H is running.

So while H does /something/, no matter what H does,
that D simulation won't reach the return statement.

Kaz finally affirmed the key element of my proof
after waiting three years for this.

This is the key element of my semantic properties of
FINITE STRING INPUTS. This is a correction and an
elaboration of Rice's theorem semantic properties
of programs.

It seems (and this is not totally verified) that Rice
is talking at an abstract level that ignores that Turing
machines only take finite string inputs and not other
actual Turing Machines. His proof seem seems to assume
actual Turing machines as inputs. I correct that error.

Second Semantic Properties of Finite String Inputs (SPoFSI)
are stipulated to be measured on the basis of the behavior
of an input P simulated by a decider** H on the basis of
H simulating N instructions of input P according to the
semantics of the specification language of P.

** Technically H is a partial decider or a termination analyzer.

And you believe that this will get you written into the history books as
the researcher who showed that the halting problem is all wrong.

You think that math/CS academia will see it from your perspective and
just agree that when H detaches from D, the question of whether the
abandoned simulation is terminating becomes off-limits (like some sort "inadmissible evidence")?

This whole aspect of what you have been saying has
been refuted. When you resume the simulation from
the exact same machine state where H.i == 3 then
you get the same result. When you do it differently
then this then it is not any actual resumption.

But at least hopefully you did see that the simulation of D started by H
can be completed, resulting in the same total 11 wsteps as a directly executed D. (It just cannot all happen while H is running; H obviously cannot be the sole driver which pushes the simulation to completion,
since it only pushes the first three steps.)

Only when you cheat and do not resume at the exact same
machine state where H.i == 3.

I and others have not lied or been mistaken in any observations about
what is going on. Everyone agrees that H returned false after certain
steps that were correct up to that point, that the input didn't reach
its return statement while simulated by H, and that there is an
unfinished simulation that can be continued and has been correctly shown
to reach its return statemnt.

Because the same not reached the "return" statement
would occur for an infinite number of simulated steps
any case of D reaching its "return" instruction is
some sort of cheating by not resuming at the exact
same machine state where H rejected D.

Your whole position is that if a simluation does not reach
termination /while being simulated by the decider/ then it
is correct to call it nonterminating.

When H correctly predicts that if it simulated D an infinite
number of steps that its simulated D would never reach its own
simulated "return" statement then H is necessarily correct
to reject D on the basis of Semantic Properties of Finite
String Inputs (SPoFSI).

(If not absolutely then
at least in situations when the input is the diagonal case).

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- PyGate Linux v1.5
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)