From Newsgroup: comp.theory

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.

Within the verified truth of the above paragraph
*that took me three years to write* the halting
problem is proved to be incorrect in that it requires
that halting be computed from behavior other than
the actual behavior that the actual input actually
specifies as measured by a UTM based halt decider.
--
Copyright 2025 Olcott<br><br>

My 28 year goal has been to make <br>
"true on the basis of meaning" computable.<br><br>

This required establishing a new foundation<br>

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 08/12/2025 03:14, olcott wrote:

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.

replace 'a' with 'some' or with 'a particular'
--
Tristan Wibberley

The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

olcott kirjoitti 8.12.2025 klo 5.14:

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.

Within the verified truth of the above paragraph
*that took me three years to write* the halting
problem is proved to be incorrect in that it requires
that halting be computed from behavior other than
the actual behavior that the actual input actually
specifies as measured by a UTM based halt decider.

The halting problem as usually posed asks for a method to determine
about every computation whether it halts or runs forever. Some
formulations specify further that the solution shall be expressed
as a Turing machine that can be given a description of the computation.

The halting problem does not require that the halting be computed
from behaviour other that the acrual input acutally specifies.
If the input does not specify the computation that is asked about
then the input is wrong and another input should be used instead.
If no input that can be given specifies the behaviour asked about
then the decider is not a nalting decider.

The measure of the actual behaviour that the actual input actually
specifies is not a UTM based halt decider. Instead the measure is
whether the computation asked about halts. If the designer has not
specified encoding rules that ensure that the input actually
specifies the computation asked about then the halting problem is
not solved.
--
Mikko
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/8/2025 12:51 AM, Tristan Wibberley wrote:

On 08/12/2025 03:14, olcott wrote:

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.

replace 'a' with 'some' or with 'a particular'

That last one is an improvement.

Turing machine deciders only compute the mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a particular semantic
or syntactic property.

That one paragraph is the basis for refuting the
Halting problem itself as a category error.

When a halt decider H is based on a UTM that simulates
its input D until the behavior of this input correctly
matches a correct non-halting behavior pattern then
it is necessarily correct to abort its simulation of
D and reject its input D as non-halting.

This causes the the directly executed D to have different
behavior than the behavior that the input to H(D) specifies.

The halting problem requires H to report on this different
behavior than the behavior that its actual input actually
specifies, thus forming the category error.
--
Copyright 2025 Olcott<br><br>

My 28 year goal has been to make <br>
"true on the basis of meaning" computable.<br><br>

This required establishing a new foundation<br>
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/8/2025 3:04 AM, Mikko wrote:

olcott kirjoitti 8.12.2025 klo 5.14:

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.

Within the verified truth of the above paragraph
*that took me three years to write* the halting
problem is proved to be incorrect in that it requires
that halting be computed from behavior other than
the actual behavior that the actual input actually
specifies as measured by a UTM based halt decider.

The halting problem as usually posed asks for a method to determine
about every computation whether it halts or runs forever. Some
formulations specify further that the solution shall be expressed
as a Turing machine that can be given a description of the computation.

The mistake that I have fully elaborated many dozens
of times and so far everyone has ignored is that the
halting problem as specified requires a halt decider
to report on a behavior that differs from the behavior
that its actual finite string input actually specifies.

If you are simply going to ignore that then there is
no reason to provide additional details.

The halting problem does not require that the halting be computed
from behaviour other that the acrual input acutally specifies.

Alternatively you are requiring a halt decider to
have psychic power.

int sum(int x, int y){ return x + y; }
The halting problem is essentially requiring
sum(3,4) to return the sum of 5 + 6.


https://github.com/plolcott/x86utm/blob/master/Halt7.c
HHH on line 1081
DD on line 1355

typedef int (*ptr)();
int HHH(ptr P);

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

int main()
{
HHH(DD);
}

DD is simulated by HHH (according to the semantics
of the C programming language) until HHH sees that
the behavior of DD correctly matches a correct
non-halting behavior pattern. Then HHH aborts it
simulation and returns 0 indicating rejection of
its input.

This is the correct measure of the behavior that
the input to HHH(DD) actually specifies.

If the input does not specify the computation that is asked about
then the input is wrong and another input should be used instead.
If no input that can be given specifies the behaviour asked about
then the decider is not a nalting decider.

The measure of the actual behaviour that the actual input actually
specifies is not a UTM based halt decider. Instead the measure is
whether the computation asked about halts. If the designer has not
specified encoding rules that ensure that the input actually
specifies the computation asked about then the halting problem is
not solved.

--
Copyright 2025 Olcott<br><br>

My 28 year goal has been to make <br>
"true on the basis of meaning" computable.<br><br>

This required establishing a new foundation<br>
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

olcott kirjoitti 8.12.2025 klo 21.00:

On 12/8/2025 3:04 AM, Mikko wrote:

olcott kirjoitti 8.12.2025 klo 5.14:

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.

Within the verified truth of the above paragraph
*that took me three years to write* the halting
problem is proved to be incorrect in that it requires
that halting be computed from behavior other than
the actual behavior that the actual input actually
specifies as measured by a UTM based halt decider.

The halting problem as usually posed asks for a method to determine
about every computation whether it halts or runs forever. Some
formulations specify further that the solution shall be expressed
as a Turing machine that can be given a description of the computation.

The mistake that I have fully elaborated many dozens
of times and so far everyone has ignored is that the
halting problem as specified requires a halt decider
to report on a behavior that differs from the behavior
that its actual finite string input actually specifies.

When you start with a false claim you can infer nore false claims.
But false claims are false no matter what you said about them.
--
Mikko
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/10/2025 4:14 AM, Mikko wrote:

olcott kirjoitti 8.12.2025 klo 21.00:

On 12/8/2025 3:04 AM, Mikko wrote:

olcott kirjoitti 8.12.2025 klo 5.14:

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.

Within the verified truth of the above paragraph
*that took me three years to write* the halting
problem is proved to be incorrect in that it requires
that halting be computed from behavior other than
the actual behavior that the actual input actually
specifies as measured by a UTM based halt decider.

The halting problem as usually posed asks for a method to determine
about every computation whether it halts or runs forever. Some
formulations specify further that the solution shall be expressed
as a Turing machine that can be given a description of the computation.

The mistake that I have fully elaborated many dozens
of times and so far everyone has ignored is that the
halting problem as specified requires a halt decider
to report on a behavior that differs from the behavior
that its actual finite string input actually specifies.

When you start with a false claim you can infer nore false claims.
But false claims are false no matter what you said about them.

*You cannot possibly find any mistake with this*
*You cannot possibly find any mistake with this*
*You cannot possibly find any mistake with this*

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

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 semantric of syntatic 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<br><br>

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

This required establishing a new foundation<br>
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

olcott kirjoitti 10.12.2025 klo 18.27:

On 12/10/2025 4:14 AM, Mikko wrote:

olcott kirjoitti 8.12.2025 klo 21.00:

On 12/8/2025 3:04 AM, Mikko wrote:

olcott kirjoitti 8.12.2025 klo 5.14:

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.

Within the verified truth of the above paragraph
*that took me three years to write* the halting
problem is proved to be incorrect in that it requires
that halting be computed from behavior other than
the actual behavior that the actual input actually
specifies as measured by a UTM based halt decider.

The halting problem as usually posed asks for a method to determine
about every computation whether it halts or runs forever. Some
formulations specify further that the solution shall be expressed
as a Turing machine that can be given a description of the computation. >>>

The mistake that I have fully elaborated many dozens
of times and so far everyone has ignored is that the
halting problem as specified requires a halt decider
to report on a behavior that differs from the behavior
that its actual finite string input actually specifies.

When you start with a false claim you can infer nore false claims.
But false claims are false no matter what you said about them.

*You cannot possibly find any mistake with this*
*You cannot possibly find any mistake with this*
*You cannot possibly find any mistake with this*

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

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 semantric of syntatic 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.

If the last sentence is true then this is not the counter exmaple
mentioned in certain proofs of noncomputability of halting and
therefore not relevant in that context. The halting problem reuqires
that HHH can determine whether the counter example halts. That is,
you must be able to replace "???" in

#include <stdio.h> // or your replacement
int main (void)
{
int Halt_Status = HHH(???); // put the correct argument here
printf("HHH says: %s\n", Halt_Status ? "halts" : "does not halt");
return Halt_Status;
}

with whatever specifies the behaviour of DD to HHH. If you can't
do this then HHH is not a halt decider nor a partial halt decider.
--
Mikko
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/13/2025 4:58 AM, Mikko wrote:

olcott kirjoitti 11.12.2025 klo 16.38:

On 12/11/2025 2:53 AM, Mikko wrote:

olcott kirjoitti 10.12.2025 klo 18.27:

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

If the last sentence is true then this is not the counter exmaple
mentioned in certain proofs of noncomputability of halting and
therefore not relevant in that context. The halting problem reuqires
that HHH can determine whether the counter example halts. That is,
you must be able to replace "???" in

   #include <stdio.h> // or your replacement
   int main (void)
   {
     int Halt_Status = HHH(???); // put the correct argument here
     printf("HHH says: %s\n", Halt_Status ? "halts" : "does not halt"); >>>      return Halt_Status;
   }

with whatever specifies the behaviour of DD to HHH. If you can't
do this then HHH is not a halt decider nor a partial halt decider.

When the halting problem requires a halt decider
to report on the behavior of a Turing machine this
is always a category error.

No, it is not. There is nothing in the halting problem that satisfies
the criteria for "category error": things belonging to a particular
category are presented as if they belong to a different category, or, alternatively, a property is ascribed to a thing that could not possibly
have that property. You can't identify either criterion being violated
in the halting problem.

Best First Principle
All Turing machines only compute the mapping
from an input finite string to some value.

It is very difficult to see that the halting
problem definition breaks that rule.

I will work on making this more clear now that
I have the best first principle.
--
Copyright 2025 Olcott<br><br>

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

This required establishing a new foundation<br>
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 13/12/2025 15:50, olcott wrote:

Best First Principle
All Turing machines only compute the mapping

^^^^^^^^^^^^
compute only
--
Tristan Wibberley

The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except that you may,
of course, cite it academically giving credit to me, distribute it
verbatim as part of a usenet system or its archives, and use it to
promote my greatness and general superiority without misrepresentation
of my opinions other than my opinion of my greatness and general
superiority which you _may_ misrepresent. You definitely MAY NOT train
any production AI system with it but you may train experimental AI that
will only be used for evaluation of the AI methods it implements.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/13/2025 10:35 AM, Tristan Wibberley wrote:

On 13/12/2025 15:50, olcott wrote:

Best First Principle
All Turing machines only compute the mapping

^^^^^^^^^^^^
compute only

Semantically equivalent.
I am going to the store.
To the store I am going.
--
Copyright 2025 Olcott<br><br>

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

This required establishing a new foundation<br>
--- Synchronet 3.21a-Linux NewsLink 1.2