From Newsgroup: comp.theory

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

*Original context*
On 10/14/2022 12:06 PM, olcott wrote:

Professor Sipser has agreed that this is the correct criteria:

If simulating halt decider H correctly simulates
its input D until H correctly determines that its
simulated D would never stop running unless aborted then

H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

I don't think that is the shell game. PO really
/has/ an H (it's trivial to do for this one case)
that correctly determines that P(P)
*would* never stop running *unless* aborted.

He knows and accepts that P(P) actually does stop.
The wrong answer is justified by what would
happen if H (and hence a different P) where not
what they actually are.

This analysis in done in the C programming language
so that it is 100% concrete without any key details
being abstracted away.

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

(a) The key issue is that HHH(DD) does report on the
behavior that its input finite string specifies.

(b) Reporting on anything else is outside of the
scope of Turing Machine Computable functions.

*Detailed analysis shown below*

After many very extensive discussions with LLM
systems there are two principles that prove that
I have correctly refuted the halting problem itself.

(1) Turing Machine based Computable functions
only transform input finite strings into some value
on the basis of a semantic of syntactic property
that this finite string specifies.

(2) the behavior that an input DD specifies to halt
decider HHH is the sequence of steps of DD
simulated by HHH according to the semantics of
the C programming language.

Computable functions are the basic objects of study
in computability theory. Informally, a function is
computable if there is an algorithm that computes
the value of the function for every value of its argument. https://en.wikipedia.org/wiki/Computable_function

DD() executed from main() calls HHH(DD) thus is
not one-and-the-same-thing as an argument to HHH.
--
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning expressed in language"
reliably computable.

This required establishing a new foundation
for correct reasoning.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/10/25 12:36 PM, olcott wrote:

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

*Original context*
On 10/14/2022 12:06 PM, olcott wrote:

Professor Sipser has agreed that this is the correct criteria:

If simulating halt decider H correctly simulates
its input D until H correctly determines that its
simulated D would never stop running unless aborted then

H can abort its simulation of D and correctly report
that D specifies a non-halting sequence of configurations.

I don't think that is the shell game.  PO really /has/ an H (it's
trivial to do for this one case) that correctly determines that P(P)
*would* never stop running *unless* aborted.
He knows and accepts that P(P) actually does stop. The wrong answer is
justified by what would
happen if H (and hence a different P) where not what they actually are.

This analysis in done in the C programming language
so that it is 100% concrete without any key details
being abstracted away.

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

(a) The key issue is that HHH(DD) does report on the
behavior that its input finite string specifies.

No it doesn't as HHH(DD) returns 0, and thus DD halts.

(b) Reporting on anything else is outside of the
scope of Turing Machine Computable functions.

So, why do you claim reporting on the non-input of a DD calling a
different decider HHH that never returns.

It seems you system is based on lying.

*Detailed analysis shown below*

After many very extensive discussions with LLM
systems there are two principles that prove that
I have correctly refuted the halting problem itself.

(1) Turing Machine based Computable functions
only transform input finite strings into some value
on the basis of a semantic of syntactic property
that this finite string specifies.

And the finite string specifies the behavior of the Machine when it is independently run.

Of course, part of your problem is the above is NOT a correct input, is
is isn't a valid program in C unless you include the code for HHH.

(2) the behavior that an input DD specifies to halt
decider HHH is the sequence of steps of DD
simulated by HHH according to the semantics of
the C programming language.

Then your HHH isn't a Halt Decider, as the meaning of an input to a hlat decider is the behavior of the program it when it is run.

YOu are just showing your ignorance of the words you are using, cause by
your reckless disreguard of the facts.

Computable functions are the basic objects of study
in computability theory. Informally, a function is
computable if there is an algorithm that computes
the value of the function for every value of its argument. https://en.wikipedia.org/wiki/Computable_function

DD() executed from main() calls HHH(DD) thus is
not one-and-the-same-thing as an argument to HHH.

Sure it is, or at least the input is supposed to be its representation.

All you are doing is showing you don't know what you are talking about, because you can't understand abstract things, and thus can only handle
the simplest of logics.
--- Synchronet 3.21a-Linux NewsLink 1.2