From Newsgroup: comp.theory

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules" https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.
--
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

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules" https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact that
the rest of you claims are wrong.

So what?


--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/25 6:19 PM, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules" https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

And is just wrong.

For instance, a RASP based decider uses no strings, but might use a
numeric representatio of a string.

And in the more generic version of the theory, are not restricted to
just Accepting or Rejecting the input.

Sorry, you are asking people to confirm things that are not actually
true in the way you think.

It seems you stumbled upon a partially true statement (true in some
versions of the system) but are focused on a part that is not an actual
basis.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact that
the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.
--
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 12/21/25 7:00 PM, olcott wrote:

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact
that the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

But Deciders don't need to be based on Strings at all.

For instance, a Program Decider could be based on representing the
algorithm as a number, just like Godel did with his G statement.

So your "First Principle" is just a lie.

So, you just admitted you wasted 21.5 years.


--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/2025 5:40 PM, Richard Damon wrote:

On 12/21/25 6:19 PM, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

And is just wrong.

For instance, a RASP based decider uses no strings, but might use a
numeric representatio of a string.

That may be an actual exception yet over-complicates
the essence that I need to convey.

And in the more generic version of the theory, are not restricted to
just Accepting or Rejecting the input.

Decider seems to be limited to deciding.

Sorry, you are asking people to confirm things that are not actually
true in the way you think.

It seems you stumbled upon a partially true statement (true in some
versions of the system) but are focused on a part that is not an actual basis.

--
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

Le 22/12/2025 à 01:00, olcott a écrit :

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact that
the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

It took you 21.5 years to state a pointless definition that in no way
support your other silly claims?

Congrats !


--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/2025 6:06 PM, Richard Damon wrote:

On 12/21/25 7:00 PM, olcott wrote:

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact
that the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

But Deciders don't need to be based on Strings at all.

A sequence of (can't possibly exist because they
are infinitely large) registers is essentially
a string. Computations involving infinite strings
cannot halt.

For instance, a Program Decider could be based on representing the
algorithm as a number, just like Godel did with his G statement.

So your "First Principle" is just a lie.

So, you just admitted you wasted 21.5 years.

--
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

Le 22/12/2025 à 01:33, olcott a écrit :

On 12/21/2025 6:06 PM, Richard Damon wrote:

On 12/21/25 7:00 PM, olcott wrote:

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>
*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact
that the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

But Deciders don't need to be based on Strings at all.

A sequence of (can't possibly exist because they
are infinitely large) registers is essentially
a string. Computations involving infinite strings
cannot halt.

Good as there are no infinite strings mentioned in any work about Halt Deciders.

Your straw man argument failed.




--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/2025 6:28 PM, Python wrote:

Le 22/12/2025 à 01:00, olcott a écrit :

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact
that the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

It took you 21.5 years to state a pointless definition that in no way support your other silly claims?
Congrats !

Do you understand that whatever conclusion
is derived through correct semantic entailment
from definitions is a necessary consequence of
these definitions?
--
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

Le 22/12/2025 à 01:38, olcott a écrit :

On 12/21/2025 6:28 PM, Python wrote:

Le 22/12/2025 à 01:00, olcott a écrit :

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>
*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact
that the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

It took you 21.5 years to state a pointless definition that in no way
support your other silly claims?
Congrats !

Do you understand that whatever conclusion
is derived through correct semantic entailment
from definitions is a necessary consequence of
these definitions?

I'm not playing shell games crank Olcott :-) ?


--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/25 7:15 PM, olcott wrote:

On 12/21/2025 5:40 PM, Richard Damon wrote:

On 12/21/25 6:19 PM, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

And is just wrong.

For instance, a RASP based decider uses no strings, but might use a
numeric representatio of a string.

That may be an actual exception yet over-complicates
the essence that I need to convey.

It is a GENERAL exception, so it can't be the rule.

And in the more generic version of the theory, are not restricted to
just Accepting or Rejecting the input.

Decider seems to be limited to deciding.

Nope, they started out that way, but there use expanded. That is the
problem of working blind, you can't know what you are doing.

"Seems" is an admittion that you don't actually know.

Remember the definition on wikipedia, "A Decider is a Turing Machine
that halts on every input"

That doesn't limit it to machines with two output states.

Yes, it means the term has outgrown its roots, but that happens with languages.

Sorry, you are asking people to confirm things that are not actually
true in the way you think.

It seems you stumbled upon a partially true statement (true in some
versions of the system) but are focused on a part that is not an
actual basis.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/25 7:33 PM, olcott wrote:

On 12/21/2025 6:06 PM, Richard Damon wrote:

On 12/21/25 7:00 PM, olcott wrote:

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>
*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact
that the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

But Deciders don't need to be based on Strings at all.

A sequence of (can't possibly exist because they
are infinitely large) registers is essentially
a string. Computations involving infinite strings
cannot halt.

No they are not. A string is built from a finite length of symbols from
a finite alphabet.

A RASP machine has cells with values from a countably infinite set of
values.

Note, any given RASP machine, like the tape of a Turing Machine is
infinite in capacity, but only has a finite number of "non-empty" cells.
FOr the Turing machine they are generally assumed to be spaces, for a
RASP machine they are zeros.

It seems you talk faster than you think (which isn't too hard for you)

And even when you allow the machine to be given an infinite tape/memory
(and it is, just most of it is blank/zero), that doesn't mean it can not
halt. It can't look at all the tape, but nothing in its definition says
it needs to.

You just can't expect to get answers that need to look at the full tape.

For instance, a Program Decider could be based on representing the
algorithm as a number, just like Godel did with his G statement.

So your "First Principle" is just a lie.

So, you just admitted you wasted 21.5 years.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/25 7:38 PM, olcott wrote:

On 12/21/2025 6:28 PM, Python wrote:

Le 22/12/2025 à 01:00, olcott a écrit :

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>
*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact
that the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

It took you 21.5 years to state a pointless definition that in no way
support your other silly claims?
Congrats !

Do you understand that whatever conclusion
is derived through correct semantic entailment
from definitions is a necessary consequence of
these definitions?

And when you start with wrong definitions, you can't say anything about
the results.

To have right definitions, you need to have studied the basics, and if
you have, you could refer to them.

Since you admitted your "logic" is based on not having looked at the
basics, but trying to "deduce" the first-principle from ZERO-Principles,
all you have done is admitted you don't actually know what you are
talking about.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/2025 6:41 PM, Richard Damon wrote:

On 12/21/25 7:15 PM, olcott wrote:

On 12/21/2025 5:40 PM, Richard Damon wrote:

On 12/21/25 6:19 PM, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

And is just wrong.

For instance, a RASP based decider uses no strings, but might use a
numeric representatio of a string.

That may be an actual exception yet over-complicates
the essence that I need to convey.

It is a GENERAL exception, so it can't be the rule.

And in the more generic version of the theory, are not restricted to
just Accepting or Rejecting the input.

Decider seems to be limited to deciding.

Nope, they started out that way, but there use expanded. That is the
problem of working blind, you can't know what you are doing.

"Seems" is an admittion that you don't actually know.

Remember the definition on wikipedia, "A Decider is a Turing Machine
that halts on every input"

That doesn't limit it to machines with two output states.

Yes, it means the term has outgrown its roots, but that happens with languages.

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.

*Here is how I first said that On 6/10/2017 1:32 PM*

Basically I formalize the entire set of all
knowledge (mathematical and otherwise) simply
as finite string transformation rules.

https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*I said this in a much more precise way now*
For the entire body of knowledge it is only
"finite string transformation rules" that validate
"true on the basis of meaning expressed in language"
--
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 12/21/2025 6:51 PM, Richard Damon wrote:

On 12/21/25 7:38 PM, olcott wrote:

On 12/21/2025 6:28 PM, Python wrote:

Le 22/12/2025 à 01:00, olcott a écrit :

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>>
*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact
that the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

It took you 21.5 years to state a pointless definition that in no way
support your other silly claims?
Congrats !

Do you understand that whatever conclusion
is derived through correct semantic entailment
from definitions is a necessary consequence of
these definitions?

And when you start with wrong definitions, you can't say anything about
the results.

Still
a necessary consequence of these definitions.

To have right definitions, you need to have studied the basics, and if
you have, you could refer to them.

Since you admitted your "logic" is based on not having looked at the
basics, but trying to "deduce" the first-principle from ZERO-Principles,
all you have done is admitted you don't actually know what you are
talking about.

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.

and the standard definition of the halting problem
are the only definitional basis that I need.
--
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 12/21/25 7:53 PM, olcott wrote:

On 12/21/2025 6:41 PM, Richard Damon wrote:

On 12/21/25 7:15 PM, olcott wrote:

On 12/21/2025 5:40 PM, Richard Damon wrote:

On 12/21/25 6:19 PM, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>
*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

And is just wrong.

For instance, a RASP based decider uses no strings, but might use a
numeric representatio of a string.

That may be an actual exception yet over-complicates
the essence that I need to convey.

It is a GENERAL exception, so it can't be the rule.

And in the more generic version of the theory, are not restricted to
just Accepting or Rejecting the input.

Decider seems to be limited to deciding.

Nope, they started out that way, but there use expanded. That is the
problem of working blind, you can't know what you are doing.

"Seems" is an admittion that you don't actually know.

Remember the definition on wikipedia, "A Decider is a Turing Machine
that halts on every input"

That doesn't limit it to machines with two output states.

Yes, it means the term has outgrown its roots, but that happens with
languages.

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.

But "Finite String Transformation" is too general, Turing Machine do
very precise and limited transformation.

And, in the generalized theory, they answer more than accept or reject.
You seem to be stuck on early forms of the work in the more limited domain.

If you want to work in the more limited domain, you can, you just need
to use the right wording.

If you want to describe what a Turing Machine does, why don't you use
the actual definition of a Turing Machine?

You know, how it goes through a finite set of states based on looking at
one cell on the tape at a time, and being able to change that cell by
its fixed set of rules and move to an adjacent cell.

Of course, that would mean you needing to learn how they actually work
and how to build up more complicated actions from simpler ones.

*Here is how I first said that On 6/10/2017 1:32 PM*

Basically I formalize the entire set of all
knowledge (mathematical and otherwise) simply
as finite string transformation rules.

https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

And where you are first wrong doesn't matter.

*I said this in a much more precise way now*
For the entire body of knowledge it is only
"finite string transformation rules" that validate
"true on the basis of meaning expressed in language"

But the "entire body of knowledge" is not a suitable basis.

Your problem is you just don't have justification for you faulty ideas.


--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/25 7:57 PM, olcott wrote:

On 12/21/2025 6:51 PM, Richard Damon wrote:

On 12/21/25 7:38 PM, olcott wrote:

On 12/21/2025 6:28 PM, Python wrote:

Le 22/12/2025 à 01:00, olcott a écrit :

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input. >>>>>>>>

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>>>
*This is the basis for my unique definition of a generic decider* >>>>>>>
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact >>>>>> that the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

It took you 21.5 years to state a pointless definition that in no
way support your other silly claims?
Congrats !

Do you understand that whatever conclusion
is derived through correct semantic entailment
from definitions is a necessary consequence of
these definitions?

And when you start with wrong definitions, you can't say anything
about the results.

Still
a necessary consequence of these definitions.

But a necessary consequence of an error doesn't prove anything,

Sorry, you aren't allowed to change the definitions and stay in the field.

To have right definitions, you need to have studied the basics, and if
you have, you could refer to them.

Since you admitted your "logic" is based on not having looked at the
basics, but trying to "deduce" the first-principle from ZERO-
Principles, all you have done is admitted you don't actually know what
you are talking about.

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.

and the standard definition of the halting problem
are the only definitional basis that I need.

Nope, as error doesn't prove anything.

You have to learn that you need to start from the actual right
definitions, or nothing you say means anything.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/25 7:57 PM, olcott wrote:

On 12/21/2025 6:51 PM, Richard Damon wrote:

On 12/21/25 7:38 PM, olcott wrote:

On 12/21/2025 6:28 PM, Python wrote:

Le 22/12/2025 à 01:00, olcott a écrit :

On 12/21/2025 5:35 PM, Python wrote:

Le 22/12/2025 à 00:19, olcott a écrit :

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input. >>>>>>>>

The above is my first use applying this term to a halt decider.

My first documented use of the term
"finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>>>
*This is the basis for my unique definition of a generic decider* >>>>>>>
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

So you stated a triviality that does not change a iota to the fact >>>>>> that the rest of you claims are wrong.

So what?

Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject} values.

The rest of my claims can be deduced from the above
first principle and any standard definition of the
halting problem.

It took me 21.5 years to translate my intuitions into
this definitional basis. They weren't worth much as
mere intuitions.

It took you 21.5 years to state a pointless definition that in no
way support your other silly claims?
Congrats !

Do you understand that whatever conclusion
is derived through correct semantic entailment
from definitions is a necessary consequence of
these definitions?

And when you start with wrong definitions, you can't say anything
about the results.

Still
a necessary consequence of these definitions.

To have right definitions, you need to have studied the basics, and if
you have, you could refer to them.

Since you admitted your "logic" is based on not having looked at the
basics, but trying to "deduce" the first-principle from ZERO-
Principles, all you have done is admitted you don't actually know what
you are talking about.

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.

and the standard definition of the halting problem
are the only definitional basis that I need.

And, since you then equivocate on the meaning of even your own
definitions, you just prove you lie.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must apply a
set of finite string transformation rules (specified by the semantics
of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term "finite string transformation rules" https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite string transformation rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble
--
meet ever shorter deadlines, known as "beat the clock"
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/2025 7:35 PM, Mr Flibble wrote:

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must apply a
set of finite string transformation rules (specified by the semantics
of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term "finite string transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite string transformation
rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into

It turns out that on the basis of the above definition
and other standard definitions that I have proved
that the halting problem has always been fundamentally
incorrect.

So far only ChatGPT, Claude AI and Grok totally agree
that I have completely proved my point on that basis.

Whatever conclusion is derived through correct semantic
entailment from definitions is a necessary consequence
of these definitions.
--
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 12/21/25 9:08 PM, olcott wrote:

On 12/21/2025 7:35 PM, Mr Flibble wrote:

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must apply a >>>> set of finite string transformation rules (specified by the semantics
of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term "finite string transformation rules" >>> https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite string transformation >>> rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into

Which isn't correct

It turns out that on the basis of the above definition
and other standard definitions that I have proved
that the halting problem has always been fundamentally
incorrect.

No, your logic is equivative, because you change meaning in the middle,
in other words, you LIE.

So far only ChatGPT, Claude AI and Grok totally agree
that I have completely proved my point on that basis.

Because they are just yes men,

Whatever conclusion is derived through correct semantic
entailment from definitions is a necessary consequence
of these definitions.

Nope, only form CORRECT definitions.

of course, your problem is that "correct" is a meaningless word to you
as you don't understand the concept of rules or requirement, because you
are just a pathological liar.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Le 22/12/2025 à 03:08, olcott a écrit :

On 12/21/2025 7:35 PM, Mr Flibble wrote:

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must apply a >>>> set of finite string transformation rules (specified by the semantics
of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term "finite string transformation rules" >>> https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite string transformation >>> rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into

It turns out that on the basis of the above definition
and other standard definitions that I have proved
that the halting problem has always been fundamentally
incorrect.

So far only ChatGPT, Claude AI and Grok totally agree
that I have completely proved my point on that basis.

LLMs are a deadly poison for cranks of your kind. Even OpenAI recognized
this.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/2025 8:25 PM, Python wrote:

Le 22/12/2025 à 03:08, olcott a écrit :

On 12/21/2025 7:35 PM, Mr Flibble wrote:

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must apply a >>>>> set of finite string transformation rules (specified by the semantics >>>>> of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term "finite string transformation
rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite string
transformation
rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into

It turns out that on the basis of the above definition
and other standard definitions that I have proved
that the halting problem has always been fundamentally
incorrect.

So far only ChatGPT, Claude AI and Grok totally agree
that I have completely proved my point on that basis.

LLMs are a deadly poison for cranks of your kind. Even OpenAI recognized this.

*Not in this specific case*
Whatever conclusion is derived through correct
semantic entailment from definitions is a necessary
consequence of these definitions.

The only issue that I have had with them is:
(a) They have to be reminded to pay closer attention
to exactly what was said.

(b) To only form conclusions that are semantically
entailed from definitions.
--
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 12/21/25 9:57 PM, olcott wrote:

On 12/21/2025 8:25 PM, Python wrote:

Le 22/12/2025 à 03:08, olcott a écrit :

On 12/21/2025 7:35 PM, Mr Flibble wrote:

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must
apply a
set of finite string transformation rules (specified by the semantics >>>>>> of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term "finite string transformation
rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>
*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite string
transformation
rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into

It turns out that on the basis of the above definition
and other standard definitions that I have proved
that the halting problem has always been fundamentally
incorrect.

So far only ChatGPT, Claude AI and Grok totally agree
that I have completely proved my point on that basis.

LLMs are a deadly poison for cranks of your kind. Even OpenAI
recognized this.

*Not in this specific case*
Whatever conclusion is derived through correct
semantic entailment from definitions is a necessary
consequence of these definitions.

The only issue that I have had with them is:
(a) They have to be reminded to pay closer attention
to exactly what was said.

(b) To only form conclusions that are semantically
entailed from definitions.

Not when the definitions are lies.

You need to start from CORRECT definitions, and you don't get to change
the definitions in the context you are trying to talk about.

As has been mentioned, if you want to totally start over and try to
create a whole new theory, go ahead. Just remember that no one is
required to use your theory. It will be your job to try and show it is
more applicable to the problems people want to do.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Le 22/12/2025 à 03:57, olcott a écrit :

On 12/21/2025 8:25 PM, Python wrote:

Le 22/12/2025 à 03:08, olcott a écrit :

On 12/21/2025 7:35 PM, Mr Flibble wrote:

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must apply a >>>>>> set of finite string transformation rules (specified by the semantics >>>>>> of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term "finite string transformation
rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>
*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite string
transformation
rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into

It turns out that on the basis of the above definition
and other standard definitions that I have proved
that the halting problem has always been fundamentally
incorrect.

So far only ChatGPT, Claude AI and Grok totally agree
that I have completely proved my point on that basis.

LLMs are a deadly poison for cranks of your kind. Even OpenAI recognized
this.

*Not in this specific case*

*Especially* in your specific case.


--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/2025 9:03 PM, Richard Damon wrote:

On 12/21/25 9:57 PM, olcott wrote:

On 12/21/2025 8:25 PM, Python wrote:

Le 22/12/2025 à 03:08, olcott a écrit :

On 12/21/2025 7:35 PM, Mr Flibble wrote:

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must
apply a
set of finite string transformation rules (specified by the
semantics
of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term "finite string transformation >>>>>> rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>>
*This is the basis for my unique definition of a generic decider*

Deciders: Transform finite string inputs by finite string
transformation
rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into

It turns out that on the basis of the above definition
and other standard definitions that I have proved
that the halting problem has always been fundamentally
incorrect.

So far only ChatGPT, Claude AI and Grok totally agree
that I have completely proved my point on that basis.

LLMs are a deadly poison for cranks of your kind. Even OpenAI
recognized this.

*Not in this specific case*
Whatever conclusion is derived through correct
semantic entailment from definitions is a necessary
consequence of these definitions.

The only issue that I have had with them is:
(a) They have to be reminded to pay closer attention
to exactly what was said.

(b) To only form conclusions that are semantically
entailed from definitions.

Not when the definitions are lies.

You need to start from CORRECT definitions, and you don't get to change
the definitions in the context you are trying to talk about.

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.

The theory of computation is fine, it is only
the notion of undecidability that is incorrect.
--
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 12/21/25 10:22 PM, olcott wrote:

On 12/21/2025 9:03 PM, Richard Damon wrote:

On 12/21/25 9:57 PM, olcott wrote:

On 12/21/2025 8:25 PM, Python wrote:

Le 22/12/2025 à 03:08, olcott a écrit :

On 12/21/2025 7:35 PM, Mr Flibble wrote:

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must >>>>>>>> apply a
set of finite string transformation rules (specified by the
semantics
of the x86 language) to this input.

The above is my first use applying this term to a halt decider.

My first documented use of the term "finite string transformation >>>>>>> rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/lqhDVnvUBgAJ >>>>>>>
*This is the basis for my unique definition of a generic decider* >>>>>>>
Deciders: Transform finite string inputs by finite string
transformation
rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into

It turns out that on the basis of the above definition
and other standard definitions that I have proved
that the halting problem has always been fundamentally
incorrect.

So far only ChatGPT, Claude AI and Grok totally agree
that I have completely proved my point on that basis.

LLMs are a deadly poison for cranks of your kind. Even OpenAI
recognized this.

*Not in this specific case*
Whatever conclusion is derived through correct
semantic entailment from definitions is a necessary
consequence of these definitions.

The only issue that I have had with them is:
(a) They have to be reminded to pay closer attention
to exactly what was said.

(b) To only form conclusions that are semantically
entailed from definitions.

Not when the definitions are lies.

You need to start from CORRECT definitions, and you don't get to
change the definitions in the context you are trying to talk about.

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.

The theory of computation is fine, it is only
the notion of undecidability that is incorrect.

And why is that?

Only because you don't lihe that a nature question that comes out of it
turns out to be uncomputable.

The Theory of Computations is about taking a defined mapping of some
input domain to some output range. Computability is about the question
of *IF* there exists a finite algorithm, like embodied in a machine,
that can transform a representation of the input domain to the correct
item of the output range.

THe Halting Question is about the input domain of Turing Machines with
their input, and the mapping of the behavior of that input to whether
said machine+input will halt when it is run, or continue forever

This machine can be represented by an appropriate input that has all the information to define this behavior, as shown by the fact that there
exists a UTM that can process that reperesentation to produce the exact behavior of the machine in question.

Thus, this defines a total mapping of ALL possible inputs in the domain
to values in the output range, and thus is a suitible question to ask.

THe fact that it turns out that no machine can be created that gives the
right answer to every input shows that this mapping happens to be uncomputable, and thus the problem is undecidable.

Your answer is the equivalent of saying that because we can't see atoms
with our naked eye, we can't talk about them existing.

Your mind just can't handle the concept that there are things that are
that you can not know, because it crushes your ego too much.

Sorry, but your problem is with you, not how the logic system defines
things, IT bothers you so much you have shut your eyes to the truth and
are going it can't be true because a can't see it because I have made
myself too stupid to see it.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 12/21/2025 10:07 PM, Richard Damon wrote:

On 12/21/25 10:22 PM, olcott wrote:

On 12/21/2025 9:03 PM, Richard Damon wrote:

On 12/21/25 9:57 PM, olcott wrote:

On 12/21/2025 8:25 PM, Python wrote:

Le 22/12/2025 à 03:08, olcott a écrit :

On 12/21/2025 7:35 PM, Mr Flibble wrote:

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must >>>>>>>>> apply a
set of finite string transformation rules (specified by the >>>>>>>>> semantics
of the x86 language) to this input.

The above is my first use applying this term to a halt decider. >>>>>>>>
My first documented use of the term "finite string
transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/
lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider* >>>>>>>>
Deciders: Transform finite string inputs by finite string
transformation
rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into

It turns out that on the basis of the above definition
and other standard definitions that I have proved
that the halting problem has always been fundamentally
incorrect.

So far only ChatGPT, Claude AI and Grok totally agree
that I have completely proved my point on that basis.

LLMs are a deadly poison for cranks of your kind. Even OpenAI
recognized this.

*Not in this specific case*
Whatever conclusion is derived through correct
semantic entailment from definitions is a necessary
consequence of these definitions.

The only issue that I have had with them is:
(a) They have to be reminded to pay closer attention
to exactly what was said.

(b) To only form conclusions that are semantically
entailed from definitions.

Not when the definitions are lies.

You need to start from CORRECT definitions, and you don't get to
change the definitions in the context you are trying to talk about.

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.

The theory of computation is fine, it is only
the notion of undecidability that is incorrect.

And why is that?

You will see in the other thread.
--
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 12/21/25 11:26 PM, olcott wrote:

On 12/21/2025 10:07 PM, Richard Damon wrote:

On 12/21/25 10:22 PM, olcott wrote:

On 12/21/2025 9:03 PM, Richard Damon wrote:

On 12/21/25 9:57 PM, olcott wrote:

On 12/21/2025 8:25 PM, Python wrote:

Le 22/12/2025 à 03:08, olcott a écrit :

On 12/21/2025 7:35 PM, Mr Flibble wrote:

On Sun, 21 Dec 2025 17:19:50 -0600, olcott wrote:

On 6/12/2024 11:50 AM, olcott wrote:

When we compute the mapping from the input to H(D,D) this must >>>>>>>>>> apply a
set of finite string transformation rules (specified by the >>>>>>>>>> semantics
of the x86 language) to this input.

The above is my first use applying this term to a halt decider. >>>>>>>>>
My first documented use of the term "finite string
transformation rules"
https://groups.google.com/g/comp.theory/c/TFXhleKnHmY/m/
lqhDVnvUBgAJ

*This is the basis for my unique definition of a generic decider* >>>>>>>>>
Deciders: Transform finite string inputs by finite string
transformation
rules into {Accept, Reject} values.

D halts, H is not a halt decider.

/Flibble

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into

It turns out that on the basis of the above definition
and other standard definitions that I have proved
that the halting problem has always been fundamentally
incorrect.

So far only ChatGPT, Claude AI and Grok totally agree
that I have completely proved my point on that basis.

LLMs are a deadly poison for cranks of your kind. Even OpenAI
recognized this.

*Not in this specific case*
Whatever conclusion is derived through correct
semantic entailment from definitions is a necessary
consequence of these definitions.

The only issue that I have had with them is:
(a) They have to be reminded to pay closer attention
to exactly what was said.

(b) To only form conclusions that are semantically
entailed from definitions.

Not when the definitions are lies.

You need to start from CORRECT definitions, and you don't get to
change the definitions in the context you are trying to talk about.

Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.

The theory of computation is fine, it is only
the notion of undecidability that is incorrect.

And why is that?

You will see in the other thread.

But you are wrong there too.

Sorry, all you are doing is proving you don't know what truth is, or
logic, or correct, etc.
--- Synchronet 3.21a-Linux NewsLink 1.2