On 12/17/2025 5:00 AM, Tristan Wibberley wrote:
On 17/12/2025 03:36, olcott wrote:
Turing Machines only transform finite string inputs into values.
No: "only"-ambiguity again.
No: non-elementary wrt. "values".
Maybe "finite string inputs" ought to be "expressions on finite segments
of tapes" if you're trying to talk about machines as Turing did in 1939
and physical ones at that rather than about expositions in C that are of
derived concepts.
I am trying precisely define the exact essence
of the architecture of Turing Machine computation.
Things like writing to a tape are not of the essence.
Things that are outside their scope:
(a) examining strings that are not inputs
(b) directly executing other Turing Machines
(c) Taking other actual Turing machines as inputs
Turing machine halt deciders transform input
finite strings into halt status values by applying
finite string transformations to inputs.
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values.
Right, and there correctness is based on the value they compute matching
the answer to the question they are supposed to be answering.
So, for a supposed Halt Decider, that is does the machine that finite--
string represents halt when it is run.
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values.
Right, and there correctness is based on the value they compute
matching the answer to the question they are supposed to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that finite
string represents halt when it is run.
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values.
Right, and there correctness is based on the value they compute
matching the answer to the question they are supposed to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that finite
string represents halt when it is run.
How many question include the answer in the question?
But note, the the correct answer for H(D) is determinable strictly from
the encoded finite string given to H, as UTM(D),
using that exact same--
string, will exhibit the behavior that H is supposed to answer about.
Thus, the information *IS* there, it is just that it isn't computable.
Of course, if you don't believe in UTMs as being valid, you are just admitting your whole basis of talking about a UTM based Halt Decider is invalid.
Of course, the other part of the problem is you don't realize that you
broke the UTM property of the machine you based you decider on, so you
can't use H's own simulation anymore.
You just lie that you can use wrong answers and just pretend they must
be right.
On 12/17/2025 11:01 AM, olcott wrote:
If I said a set of sequences of space delimited
binary digits each stored in the cells of a Turing
machine tape this would make it impossible for people
to see the essence of the error of the halting problem
and its proofs.
I bet not even one person here even knows what
"exhaustively tested the truth of this"
actually involves.
In this forum it seems to mean to totally understand
the conventional wisdom and construing this mere
"conventional wisdom" as infallibly correct.
On 12/17/25 11:38 PM, olcott wrote:
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
How many question include the answer in the question?
On 17/12/2025 17:09, olcott wrote:
On 12/17/2025 11:01 AM, olcott wrote:
If I said a set of sequences of space delimited
binary digits each stored in the cells of a Turing
machine tape this would make it impossible for people
to see the essence of the error of the halting problem
and its proofs.
Yeah but now you're being silly. How will you explain "string" when it
means so many different things in technical terms depending on the
reader's technical origins>
How about "sequence of icons". That could be beads (on a string) which
are sculpted icons or symbols on paper tape which are written icons.
I dunno, the terminology has got so mixed over the years it's hard. It
will happen to "icons" if you use it.
Or "sequence of indicators" which could be macro-orientations of iron
filings on magnetic tape. That will fit in with you machines that make indications.
I bet not even one person here even knows what
"exhaustively tested the truth of this"
actually involves.
It involves deciding reality.
In this forum it seems to mean to totally understand
the conventional wisdom and construing this mere
"conventional wisdom" as infallibly correct.
They're mentally substituting in "idealised".
On 18/12/2025 04:57, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
...
How many question include the answer in the question?
He said "encode" not "include". Lots of them do. All the tautologies do.
I don't think anything else does. That's the thing about tautologies
isn't it?
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values.
Right, and there correctness is based on the value they compute
matching the answer to the question they are supposed to be answering. >>>>
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that
finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
I have worked on undecidability for 28 years and have
proven to several LLM systems that my reframing of
decision problems is correct.
Because I have now done this from first principles
directly derived from standard definitions my reasoning
is finally provably sound.
But note, the the correct answer for H(D) is determinable strictly
from the encoded finite string given to H, as UTM(D),
Not when pathological self-reference is involved.
when pathological self-reference *IS NOT* involved
then H.UTM(P) derives identical behavior to UTM(P).
When pathological self-reference *IS* involved then
the behavior of H.UTM(P) derives different behavior
than UTM(P). This has been proved thousands of times.
The last key piece is how and why one of them overrules
and supersedes the other. This is correctly analyzed
from first principles derived from standard definitions.
using that exact same string, will exhibit the behavior that H is
supposed to answer about.
Thus, the information *IS* there, it is just that it isn't computable.
Of course, if you don't believe in UTMs as being valid, you are just
admitting your whole basis of talking about a UTM based Halt Decider
is invalid.
Of course, the other part of the problem is you don't realize that you
broke the UTM property of the machine you based you decider on, so you
can't use H's own simulation anymore.
You just lie that you can use wrong answers and just pretend they must
be right.
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values.
Right, and there correctness is based on the value they compute
matching the answer to the question they are supposed to be answering. >>>>>
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that
finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine what
questions are computable, that is just nonsense/
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values. >>>>>>>
Right, and there correctness is based on the value they compute
matching the answer to the question they are supposed to be
answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that
finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine what
questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
Likewise every computation must have a sufficient
basis.
Turing machines ONLY transform inputs into values
or get stuck in loops.
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values. >>>>>>>>
Right, and there correctness is based on the value they compute >>>>>>> matching the answer to the question they are supposed to be
answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that
finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine what
questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and
mechanically follow.
The DESIGNER of the algorithm needs to have a good basis if the
computation is to get the right answer.
Turing machines ONLY transform inputs into values
or get stuck in loops.
In other words, you are just showing your stupidity.
You just don't understand even the basic categories of what you talk about.
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values. >>>>>>>>>
Right, and there correctness is based on the value they compute >>>>>>>> matching the answer to the question they are supposed to be
answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that >>>>>>>> finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine what
questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and
mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
No amount of devotion to dogma can possibly change this.
Undecidability proves that the notion of truth itself is
(not coherently connected together) AKA broken.
The DESIGNER of the algorithm needs to have a good basis if the
computation is to get the right answer.
Turing machines ONLY transform inputs into values
or get stuck in loops.
In other words, you are just showing your stupidity.
You just don't understand even the basic categories of what you talk
about.
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values. >>>>>>>>>>
Right, and there correctness is based on the value they compute >>>>>>>>> matching the answer to the question they are supposed to be >>>>>>>>> answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that >>>>>>>>> finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine what
questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and
mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time.
On 12/18/2025 8:40 PM, Richard Damon wrote:
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values. >>>>>>>>>>>
Right, and there correctness is based on the value they
compute matching the answer to the question they are supposed >>>>>>>>>> to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that >>>>>>>>>> finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine what >>>>>> questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and
mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time.
It is very difficult to see that this is Counter-factual.
On 12/18/25 9:46 PM, olcott wrote:
On 12/18/2025 8:40 PM, Richard Damon wrote:
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into >>>>>>>>>>>> values.
Right, and there correctness is based on the value they >>>>>>>>>>> compute matching the answer to the question they are supposed >>>>>>>>>>> to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine >>>>>>>>>>> that finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine
what questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and
mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time.
It is very difficult to see that this is Counter-factual.
So, UTMS don't exist?
On 12/18/2025 9:08 PM, Richard Damon wrote:
On 12/18/25 9:46 PM, olcott wrote:
On 12/18/2025 8:40 PM, Richard Damon wrote:
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into >>>>>>>>>>>>> values.
Right, and there correctness is based on the value they >>>>>>>>>>>> compute matching the answer to the question they are
supposed to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine >>>>>>>>>>>> that finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine >>>>>>>> what questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and
mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time.
It is very difficult to see that this is Counter-factual.
So, UTMS don't exist?
You are on the right track.
You need much more details.
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values. >>>>>>>>>>
Right, and there correctness is based on the value they compute >>>>>>>>> matching the answer to the question they are supposed to be >>>>>>>>> answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that >>>>>>>>> finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine what
questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and
mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time.
On 12/18/25 10:36 PM, olcott wrote:
On 12/18/2025 9:08 PM, Richard Damon wrote:
On 12/18/25 9:46 PM, olcott wrote:
On 12/18/2025 8:40 PM, Richard Damon wrote:
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into >>>>>>>>>>>>>> values.
Right, and there correctness is based on the value they >>>>>>>>>>>>> compute matching the answer to the question they are >>>>>>>>>>>>> supposed to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem >>>>>>>>>>>> instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine >>>>>>>>>>>>> that finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine >>>>>>>>> what questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and >>>>>>> mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time. >>>>>
It is very difficult to see that this is Counter-factual.
So, UTMS don't exist?
You are on the right track.
You need much more details.
In other words, you don't know how to support your claim, because you
are just lying.
All you are doing is proving you are a liar and buring your reputaiton
under that pile of lies proving that you are just an ignorant
pathological liar.
So, do you believe that UTMs exist?--
If so, then your claim that the halting property is invalid is just a lie.
If you don't, then you admit that the basis of your claimed decider is
just a lie, as it needs UTMs to exist to try to justify that it can determine the answer.
Sorry, you are just killing your own theory.
Your problem is you killed your ability to reason by making yourself ignorant of the field, and then you believed your own lies.
Your have made yourself effectively brain dead.
On 12/18/25 7:59 PM, Richard Damon wrote:
On 12/18/25 10:36 PM, olcott wrote:
On 12/18/2025 9:08 PM, Richard Damon wrote:
On 12/18/25 9:46 PM, olcott wrote:
On 12/18/2025 8:40 PM, Richard Damon wrote:
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into >>>>>>>>>>>>>>> values.
Right, and there correctness is based on the value they >>>>>>>>>>>>>> compute matching the answer to the question they are >>>>>>>>>>>>>> supposed to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem >>>>>>>>>>>>> instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine >>>>>>>>>>>>>> that finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine >>>>>>>>>> what questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and >>>>>>>> mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time. >>>>>>
It is very difficult to see that this is Counter-factual.
So, UTMS don't exist?
You are on the right track.
You need much more details.
In other words, you don't know how to support your claim, because you
are just lying.
All you are doing is proving you are a liar and buring your reputaiton
under that pile of lies proving that you are just an ignorant
pathological liar.
fucking toxic-ass chief engineer u r
So, do you believe that UTMs exist?
If so, then your claim that the halting property is invalid is just a
lie.
--
If you don't, then you admit that the basis of your claimed decider is
just a lie, as it needs UTMs to exist to try to justify that it can
determine the answer.
Sorry, you are just killing your own theory.
Your problem is you killed your ability to reason by making yourself
ignorant of the field, and then you believed your own lies.
Your have made yourself effectively brain dead.
On 12/18/2025 8:40 PM, Richard Damon wrote:
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into values. >>>>>>>>>>>
Right, and there correctness is based on the value they
compute matching the answer to the question they are supposed >>>>>>>>>> to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine that >>>>>>>>>> finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine what >>>>>> questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and
mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time.
Try and show the details of that using a UTM
like you suggested.
When you erase the key context of a reply I have
to go back to that context as I have done here.
Unless you come up with the reasoning yourself
through the method called Socratic questioning
you will simply disbelieve anything that I say
as you have just done.
https://en.wikipedia.org/wiki/Socratic_questioning
actually his claim is that computing the halting property is an invalid expectation (which kind of actually agrees with ur position, just with different words). and is a bit retarded in it's own sense, but the fact
u don't know that after engaging with him for what? decades ...?
On 12/18/25 11:14 PM, olcott wrote:
On 12/18/2025 8:40 PM, Richard Damon wrote:
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into >>>>>>>>>>>> values.
Right, and there correctness is based on the value they >>>>>>>>>>> compute matching the answer to the question they are supposed >>>>>>>>>>> to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine >>>>>>>>>>> that finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine
what questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and
mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time.
Try and show the details of that using a UTM
like you suggested.
Since a UTM is DEFINED as a machine that recreates the behavior of the machine described by the input, it is just axiomatic.
If Wm is the description of machine M, and w its input.
UTM Wm w is DEFINED to behave exactly like M w, and thus provides the definition of the behavior of the input Wm w to H Wm w.
On 12/19/2025 9:11 AM, Richard Damon wrote:
On 12/18/25 11:14 PM, olcott wrote:
On 12/18/2025 8:40 PM, Richard Damon wrote:
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into >>>>>>>>>>>>> values.
Right, and there correctness is based on the value they >>>>>>>>>>>> compute matching the answer to the question they are
supposed to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem
instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine >>>>>>>>>>>> that finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine >>>>>>>> what questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and
mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time.
Try and show the details of that using a UTM
like you suggested.
Since a UTM is DEFINED as a machine that recreates the behavior of the
machine described by the input, it is just axiomatic.
If Wm is the description of machine M, and w its input.
UTM Wm w is DEFINED to behave exactly like M w, and thus provides the
definition of the behavior of the input Wm w to H Wm w.
Computations: Transform finite strings by finite
string transformation rules into values or nontermination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
When UTM(P) and H.UTM(P) vary then it is H.UTM(P)
that rules because H is only required to report on
the behavior that it actual input actually specifies.
On 12/19/2025 10:13 AM, olcott wrote:
On 12/19/2025 9:11 AM, Richard Damon wrote:
On 12/18/25 11:14 PM, olcott wrote:
On 12/18/2025 8:40 PM, Richard Damon wrote:
On 12/18/25 9:25 PM, olcott wrote:
On 12/18/2025 8:13 PM, Richard Damon wrote:
On 12/18/25 8:11 PM, olcott wrote:
On 12/18/2025 6:53 PM, Richard Damon wrote:
On 12/18/25 1:51 PM, olcott wrote:
On 12/17/2025 10:57 PM, Richard Damon wrote:
On 12/17/25 11:38 PM, olcott wrote:
On 12/17/2025 6:31 AM, Richard Damon wrote:
On 12/16/25 10:36 PM, olcott wrote:
Turing Machines only transform finite string inputs into >>>>>>>>>>>>>> values.
Right, and there correctness is based on the value they >>>>>>>>>>>>> compute matching the answer to the question they are >>>>>>>>>>>>> supposed to be answering.
If the answer to the question is not encoded in the
input then this is not an undecidable decision problem >>>>>>>>>>>> instance it is an incorrect question.
It must be actually encoded in the input such
that it can be decoded from the input otherwise
the question is incorrect.
So, for a supposed Halt Decider, that is does the machine >>>>>>>>>>>>> that finite string represents halt when it is run.
How many question include the answer in the question?
With decision problem if the answer cannot be computed
from the input then the question is incorrect.
Says who?
Since the whole purpose of Computation Theory is to determine >>>>>>>>> what questions are computable, that is just nonsense/
We cannot predict who the next president of
the United States will be on the sole basis
of the square-root of two.
So? That isn't a question that even comes up in the theory.
Likewise every computation must have a sufficient
basis.
No, every computation has an algorithm that it will blindly and >>>>>>> mechanically follow.
That seems accurate.
WhoIsNextPresidentOfUSA(√2)
(entirely on the basis of the square root of two)
So, you don't know what an algorithm is.
Seems normal for you,
The tiny little detail that no one noticed for
90 years is that in those cases where the required
output cannot be derived from the actual input it
is the requirement itself that is incorrect.
But the answer CAN be derived from the input, just not in finte time. >>>>>
Try and show the details of that using a UTM
like you suggested.
Since a UTM is DEFINED as a machine that recreates the behavior of
the machine described by the input, it is just axiomatic.
If Wm is the description of machine M, and w its input.
UTM Wm w is DEFINED to behave exactly like M w, and thus provides
the definition of the behavior of the input Wm w to H Wm w.
Computations: Transform finite strings by finite
string transformation rules into values or nontermination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
When UTM(P) and H.UTM(P) vary then it is H.UTM(P)
that rules because H is only required to report on
the behavior that it actual input actually specifies.
*Here are all of the details*
https://www.researchgate.net/ publication/398878263_Deciders_Transform_finite_strings_by_finite_string_transformation_rules_into_Accept_Reject
On 12/19/25 3:25 AM, dart200 wrote:
actually his claim is that computing the halting property is an
invalid expectation (which kind of actually agrees with ur position,
just with different words). and is a bit retarded in it's own sense,
but the fact u don't know that after engaging with him for what?
decades ...?
No, they are very different.
a-priori, we can have a reasonable expectation that asking about the
halting behavior of a machine is a reasonable thing. Every machine has a definite such behavior that is fully determined by the machine.
We know we have a way to express a machine fully to a computation
engine, as we can show that we can make such a representation that
another computation can use to recreate that original behavior.
Those are all the base requirements to be a valid question.
What happens, is it turns out the computational environment is powerful enough that the machines it can generate can grow in complexity faster
than the power to analyze them. Thus, it turns out that there are many properties of the machines that are just not "Computable".
That doesn't make such question "invalid", just not answerable.
Just like in powerful enough logic systems, there exist statements that
are actually True, but can never be proven in the system, or even
knowable at all.
This comes out of the properties of the infinite, and that we are finite beings.
Olcott just can't understand the infinite, and his logic is
fundamentally limited to system that can't create infinity. He
fundamentally can't understand the concepts that create such infinities,
and thus he is imprisoned by his finite thinking.
YOU make similar errors because like him, you refuse to learn the actual basics and insist on false concepts.
On 12/18/2025 3:30 PM, Tristan Wibberley wrote:
On 17/12/2025 17:09, olcott wrote:
On 12/17/2025 11:01 AM, olcott wrote:
If I said a set of sequences of space delimited
binary digits each stored in the cells of a Turing
machine tape this would make it impossible for people
to see the essence of the error of the halting problem
and its proofs.
Yeah but now you're being silly. How will you explain "string" when it
means so many different things in technical terms depending on the
reader's technical origins>
How many things does it mean on computation?
How about "sequence of icons". That could be beads (on a string) which
are sculpted icons or symbols on paper tape which are written icons.
I dunno, the terminology has got so mixed over the years it's hard. It
will happen to "icons" if you use it.
In C: Null terminated sequence of ASCII digits.
In Turing machines space delimited sequence of binary digits.
Computations: Transform finite strings by finite
string transformation rules into values or nontermination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
When UTM(P) and H.UTM(P) vary then it is H.UTM(P)
that rules because H is only required to report on
the behavior that it actual input actually specifies.
On 12/18/2025 3:30 PM, Tristan Wibberley wrote:
On 17/12/2025 17:09, olcott wrote:
On 12/17/2025 11:01 AM, olcott wrote:
How will you explain "string" when it
means so many different things in technical terms depending on the
reader's technical origins>
How many things does it mean on computation?
How about "sequence of icons". That could be beads (on a string) which
are sculpted icons or symbols on paper tape which are written icons.
I dunno, the terminology has got so mixed over the years it's hard. It
will happen to "icons" if you use it.
In C: Null terminated sequence of ASCII digits.
In Turing machines space delimited sequence of binary digits.
the whole purpose of Computation Theory is to determine what
questions are computable, that is just nonsense/
On 19/12/2025 00:53, Richard Damon wrote:
the whole purpose of Computation Theory is to determine what
questions are computable, that is just nonsense/
You can couch it as "to determine which sentences enquire of properties."
The reduction rules of the system provide meaning for the sentence; in
that sentence the answer is encoded wrt. those rules or else there is no answer.
The message body is Copyright (C) 2025 Tristan Wibberley except
citations and quotations noted. All Rights Reserved except as noted in
the sig.
On 18/12/2025 23:25, olcott wrote:
On 12/18/2025 3:30 PM, Tristan Wibberley wrote:
On 17/12/2025 17:09, olcott wrote:
On 12/17/2025 11:01 AM, olcott wrote:
How will you explain "string" when it
means so many different things in technical terms depending on the
reader's technical origins>
How many things does it mean on computation?
It differs among many programming systems. C, Python, Javascript,
Haskell, there are many differences between them; those include whether
they are operationally defined or are denotations, what structure they
have, whether they are growable and how big you can make them. Some of
them can't become arbitrarily large but some, perhaps, can. Some of them
can represent infinite sequences. I know of none that have two
unreachable ends and I believe that Turing's description of a Turing
Machine requires such - but perhaps my reading is incorrect.
You said or strongly implied you were trying to create foundational principles which has nothing to do with C. You can't succeed if you
restrict that only to terms other than "string".
How about "sequence of icons". That could be beads (on a string) which
are sculpted icons or symbols on paper tape which are written icons.
I dunno, the terminology has got so mixed over the years it's hard. It
will happen to "icons" if you use it.
In C: Null terminated sequence of ASCII digits.
In Turing machines space delimited sequence of binary digits.
Why is C relevant for foundational principles?
As for Turing Machines, I feel ambiguity in your sentence so I'll let it hang.
On 2025-12-18 16:25, olcott wrote:
On 12/18/2025 3:30 PM, Tristan Wibberley wrote:
On 17/12/2025 17:09, olcott wrote:
On 12/17/2025 11:01 AM, olcott wrote:
If I said a set of sequences of space delimited
binary digits each stored in the cells of a Turing
machine tape this would make it impossible for people
to see the essence of the error of the halting problem
and its proofs.
Yeah but now you're being silly. How will you explain "string" when it
means so many different things in technical terms depending on the
reader's technical origins>
How many things does it mean on computation?
How about "sequence of icons". That could be beads (on a string) which
are sculpted icons or symbols on paper tape which are written icons.
I dunno, the terminology has got so mixed over the years it's hard. It
will happen to "icons" if you use it.
In C: Null terminated sequence of ASCII digits.
In Turing machines space delimited sequence of binary digits.
Nowhere does the definition of Turing Machine mention space delimited sequences of binary digits.
André
On 12/19/25 11:13 AM, olcott wrote:
Computations: Transform finite strings by finite
string transformation rules into values or nontermination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
But XXX Deciders need to transform there finite string to {Accept,
Reject} in a manner that MATCHES the XXX function.
Since the DEFINITION of HALTING is DEFINED in terms of actual Turing--
Machine behavior, if the claimed Halt Deciders result doesn't match
that, it just isn't actually a Halt Decider, but a lie.
The correspondence of actual Turing Machines to Finite Strings is
determined by the concept of a UTM.
If the string doesn't match the behavior of the machine it is supposed
to represent, then either the wrong string was given, or your claimed
UTM isn't a UTM.
When UTM(P) and H.UTM(P) vary then it is H.UTM(P)
that rules because H is only required to report on
the behavior that it actual input actually specifies.
But H.UTM isn't actualy a UTM, or your H never answers. You can't
"redefine" what a UTM is.
IT seems your "logic" is based on being allowed to lie by mislabling
enties.
You need to decide, did you LIE about the proper input to the machine,
or did you LIE about H having a UTM at that point.
Since a machine has only one behavior, there can only be one behavior as
a result of UTM(its description). TO say they are different is just an admission that you are lying.
Trying to "redefine" what the words mean just shows your commitment to lying, and that you logic has no actual semantics.
On 12/19/2025 4:01 PM, Richard Damon wrote:
On 12/19/25 11:13 AM, olcott wrote:
Computations: Transform finite strings by finite
string transformation rules into values or nontermination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
But XXX Deciders need to transform there finite string to {Accept,
Reject} in a manner that MATCHES the XXX function.
Not when there is no transformation from the input
to the required value.
https://www.researchgate.net/ publication/398878263_Deciders_Transform_finite_strings_by_finite_string_transformation_rules_into_Accept_Reject
On 12/19/25 6:13 PM, olcott wrote:
On 12/19/2025 4:01 PM, Richard Damon wrote:
On 12/19/25 11:13 AM, olcott wrote:
Computations: Transform finite strings by finite
string transformation rules into values or nontermination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
But XXX Deciders need to transform there finite string to {Accept,
Reject} in a manner that MATCHES the XXX function.
Not when there is no transformation from the input
to the required value.
In other words, you think UTM don't exist.
On 12/19/2025 5:20 PM, Richard Damon wrote:
On 12/19/25 6:13 PM, olcott wrote:
On 12/19/2025 4:01 PM, Richard Damon wrote:
On 12/19/25 11:13 AM, olcott wrote:
Computations: Transform finite strings by finite
string transformation rules into values or nontermination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
But XXX Deciders need to transform there finite string to {Accept,
Reject} in a manner that MATCHES the XXX function.
Not when there is no transformation from the input
to the required value.
In other words, you think UTM don't exist.
This boils my whole point down much more succinctly than
ever before and it is derived from standard definitions.
Computations: Transform finite strings by finite
string transformation rules into values or non-termination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
When UTM(P) and H.UTM(P) vary then it is H.UTM(P)
that rules because H is only required to report on
the behavior that it actual input actually specifies.
On 12/19/25 6:46 PM, olcott wrote:
On 12/19/2025 5:20 PM, Richard Damon wrote:
On 12/19/25 6:13 PM, olcott wrote:
On 12/19/2025 4:01 PM, Richard Damon wrote:
On 12/19/25 11:13 AM, olcott wrote:
Computations: Transform finite strings by finite
string transformation rules into values or nontermination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
But XXX Deciders need to transform there finite string to {Accept,
Reject} in a manner that MATCHES the XXX function.
Not when there is no transformation from the input
to the required value.
In other words, you think UTM don't exist.
This boils my whole point down much more succinctly than
ever before and it is derived from standard definitions.
Computations: Transform finite strings by finite
string transformation rules into values or non-termination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
When UTM(P) and H.UTM(P) vary then it is H.UTM(P)
that rules because H is only required to report on
the behavior that it actual input actually specifies.
Nope, because you H.UTM isn't a UTM, and thus you can't use it. You
BROKE the code with your modifications.
There *IS* a transformation from the string of the input to the
behavior, and that is of a real UTM, and that DOES match the behavior of
the direct execution of the machine it describes.
You just don't understand basics, like the meaning of the words you use,--
and that rules matter.
To try to change them is to just make yourself a liar.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for
the classes.
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for
the classes.
On 12/19/2025 8:57 PM, Richard Damon wrote:
On 12/19/25 6:46 PM, olcott wrote:
On 12/19/2025 5:20 PM, Richard Damon wrote:
On 12/19/25 6:13 PM, olcott wrote:
On 12/19/2025 4:01 PM, Richard Damon wrote:
On 12/19/25 11:13 AM, olcott wrote:
Computations: Transform finite strings by finite
string transformation rules into values or nontermination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
But XXX Deciders need to transform there finite string to {Accept, >>>>>> Reject} in a manner that MATCHES the XXX function.
Not when there is no transformation from the input
to the required value.
In other words, you think UTM don't exist.
This boils my whole point down much more succinctly than
ever before and it is derived from standard definitions.
Computations: Transform finite strings by finite
string transformation rules into values or non-termination.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
When UTM(P) and H.UTM(P) vary then it is H.UTM(P)
that rules because H is only required to report on
the behavior that it actual input actually specifies.
Nope, because you H.UTM isn't a UTM, and thus you can't use it. You
BROKE the code with your modifications.
If H is only a UTM then H(P) never halts.
If H is a UTM that simply stops after one million
steps then H reaches its final halt state and P
never reaches is final halt state.
There *IS* a transformation from the string of the input to the
behavior, and that is of a real UTM, and that DOES match the behavior
of the direct execution of the machine it describes.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // accept state
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // reject state
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // accept state
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // reject state
The behavior of Ĥ applied to ⟨Ĥ⟩ and H applied to ⟨Ĥ⟩
is not the same.
You just don't understand basics, like the meaning of the words you
use, and that rules matter.
To try to change them is to just make yourself a liar.
On 12/20/2025 7:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for
the classes.
That is not any sort of actual rebuttal
it is merely a dogmatic assertion. Actual
rebuttals (even incorrect ones) require reasoning.
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes
might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting actual programs instead of merely characterising them, whether Olcott is doing
the politics or is being nudged by search results into effecting another group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any
formal meaning in logistic philosophy is almost diluted away.
On 20/12/2025 13:12, olcott wrote:
On 12/20/2025 7:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for
the classes.
That is not any sort of actual rebuttal
it is merely a dogmatic assertion. Actual
rebuttals (even incorrect ones) require reasoning.
I gave it to you before, I think.
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of sentences matching a defined language, and they are to ACCEPT strings--
that match that grammar, and REJECT statements that fail to meet the grammar.
"Halt Deciders" can be considered to be of that type of deciders, where
the grammar defines that a given string represents a finite computation.
On 12/20/2025 4:57 PM, Tristan Wibberley wrote:
On 20/12/2025 13:12, olcott wrote:
On 12/20/2025 7:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for >>>> the classes.
That is not any sort of actual rebuttal
it is merely a dogmatic assertion. Actual
rebuttals (even incorrect ones) require reasoning.
I gave it to you before, I think.
It is categorically impossible for this to be
incorrect:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
"Halt Deciders" can be considered to be of that type of deciders,
where the grammar defines that a given string represents a finite
computation.
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes
might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting actual programs instead of merely characterising them, whether Olcott is doing
the politics or is being nudged by search results into effecting another group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any
formal meaning in logistic philosophy is almost diluted away.
On 12/20/25 6:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for >>>> the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes
might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting actual
programs instead of merely characterising them, whether Olcott is doing
the politics or is being nudged by search results into effecting another
group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any
formal meaning in logistic philosophy is almost diluted away.
The use of the term "Halt Decider" and "Turing Machine" focus the
context fairly well. Add in his rambling about the Halting Problem, and
it seems clear.
Of course, it does also show is limited understanding, as deciders only answering Accept or Reject is a somewhat limited space in that field,
but was the initial field which used the term.
On 12/20/25 6:25 PM, olcott wrote:
On 12/20/2025 4:57 PM, Tristan Wibberley wrote:
On 20/12/2025 13:12, olcott wrote:
On 12/20/2025 7:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels >>>>> for
the classes.
That is not any sort of actual rebuttal
it is merely a dogmatic assertion. Actual
rebuttals (even incorrect ones) require reasoning.
I gave it to you before, I think.
It is categorically impossible for this to be
incorrect:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
No, you are categorically incorrect. While they may only USE a finite
string transformation, they are accoutable to the function they are
supposed to be computing.
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for >>>> the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few minutes
of searching. It is basic material in Computation Theory in the
introductory material on Deciders.
Of course, you just admitted that you don't understand the context of
the statement, so you don't know how to actually use it.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
"Halt Deciders" can be considered to be of that type of deciders,
where the grammar defines that a given string represents a finite
computation.
On 12/20/2025 5:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for >>>> the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
Not at all. I intentionally made it model free.
It uniformly applies to all models.
I cannot get people to understand the basic gist of
what I am saying unless I make it ridiculously succinct.
With some people here I have to repeat the same simple
point fifty times before they ever notice that I said
it at least once.
English words. The capitalisation is not really enough; double-quotes
might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting actual
programs instead of merely characterising them, whether Olcott is doing
the politics or is being nudged by search results into effecting another
group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any
formal meaning in logistic philosophy is almost diluted away.
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels >>>>> for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few
minutes of searching. It is basic material in Computation Theory in
the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Of course, you just admitted that you don't understand the context of
the statement, so you don't know how to actually use it.
In ONE of the version of defining Deciders, they are determinators
of sentences matching a defined language, and they are to ACCEPT
strings that match that grammar, and REJECT statements that fail to
meet the grammar.
"Halt Deciders" can be considered to be of that type of deciders,
where the grammar defines that a given string represents a finite
computation.
On 12/20/25 6:37 PM, olcott wrote:
On 12/20/2025 5:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels >>>>> for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
Not at all. I intentionally made it model free.
It uniformly applies to all models.
Nope, but then because of your self-imposed ignorance, you don't
understand the overloading of the term model.
Yes, the terminolgy works over different processing models of
computation, like Turing Machine, RASP machines, etc.
But another meaning is classifications of problems to handle.
Accept/Reject results come out of the model of questions which are identifying if a given string matches a specificed language/grammar
where either the string does or does not meet the requirements. In such
a model, all Functions being computed have a boolean result.
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few
minutes of searching. It is basic material in Computation Theory in
the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
Which begins:
Question: If a TM is given a string, what can happen to the computation?
Answer: The machine can either
1. Accept the string (ie enter the Accept state and halt the computation)
2. Reject the string (ie enter the Reject state and halt the computation)
3. Enter an Infinite Loop (ie the computation never ends)
Thus introducing the idea that machines can accept or reject the input.
On 12/20/2025 5:32 PM, Richard Damon wrote:
On 12/20/25 6:25 PM, olcott wrote:
On 12/20/2025 4:57 PM, Tristan Wibberley wrote:
On 20/12/2025 13:12, olcott wrote:
On 12/20/2025 7:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is not any sort of actual rebuttal
it is merely a dogmatic assertion. Actual
rebuttals (even incorrect ones) require reasoning.
I gave it to you before, I think.
It is categorically impossible for this to be
incorrect:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
No, you are categorically incorrect. While they may only USE a finite
string transformation, they are accoutable to the function they are
supposed to be computing.
They cannot be held accountable for any behavior
outside the scope of deciders as I have carefully
defined them. They cannot be required to bake
birthday cakes or use any psychic ability.
All that they can be required to do is transform
input finite strings into values.
On 12/20/2025 5:14 PM, Richard Damon wrote:
On 12/20/25 6:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels >>>>> for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes
might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting actual >>> programs instead of merely characterising them, whether Olcott is doing
the politics or is being nudged by search results into effecting another >>> group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any
formal meaning in logistic philosophy is almost diluted away.
The use of the term "Halt Decider" and "Turing Machine" focus the
context fairly well. Add in his rambling about the Halting Problem,
and it seems clear.
Of course, it does also show is limited understanding, as deciders
only answering Accept or Reject is a somewhat limited space in that
field, but was the initial field which used the term.
It is the semantics of accept and reject no matter
what they are called or how they are encoded. Also
the model of computation makes no difference.
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few
minutes of searching. It is basic material in Computation Theory in
the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
Which begins:
Question: If a TM is given a string, what can happen to the computation?
Answer: The machine can either
1. Accept the string (ie enter the Accept state and halt the computation)
2. Reject the string (ie enter the Reject state and halt the computation)
3. Enter an Infinite Loop (ie the computation never ends)
Thus introducing the idea that machines can accept or reject the input.
Where on Earth can you find that this must be
anchored in finite string transformation rules?
On 12/20/2025 5:55 PM, Richard Damon wrote:
On 12/20/25 6:37 PM, olcott wrote:
On 12/20/2025 5:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of >>>>> sentences matching a defined language, and they are to ACCEPT strings >>>>> that match that grammar, and REJECT statements that fail to meet the >>>>> grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
Not at all. I intentionally made it model free.
It uniformly applies to all models.
Nope, but then because of your self-imposed ignorance, you don't
understand the overloading of the term model.
Yes, the terminolgy works over different processing models of
computation, like Turing Machine, RASP machines, etc.
But another meaning is classifications of problems to handle.
Accept/Reject results come out of the model of questions which are
identifying if a given string matches a specificed language/grammar
where either the string does or does not meet the requirements. In
such a model, all Functions being computed have a boolean result.
Is there any other term besides accept/reject for
the subset of decision problems that are deciders?
On 12/20/25 6:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for >>>> the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes
might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting actual
programs instead of merely characterising them, whether Olcott is doing
the politics or is being nudged by search results into effecting another
group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any
formal meaning in logistic philosophy is almost diluted away.
The use of the term "Halt Decider" and "Turing Machine" focus the
context fairly well. Add in his rambling about the Halting Problem, and
it seems clear.
Of course, it does also show is limited understanding, as deciders only answering Accept or Reject is a somewhat limited space in that field,
but was the initial field which used the term.
On 20/12/2025 23:14, Richard Damon wrote:
On 12/20/25 6:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for >>>>> the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes
might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting actual >>> programs instead of merely characterising them, whether Olcott is doing
the politics or is being nudged by search results into effecting another >>> group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any
formal meaning in logistic philosophy is almost diluted away.
The use of the term "Halt Decider" and "Turing Machine" focus the
context fairly well. Add in his rambling about the Halting Problem, and
it seems clear.
Of course, it does also show is limited understanding, as deciders only
answering Accept or Reject is a somewhat limited space in that field,
but was the initial field which used the term.
Do you mean to say that Computation Theory first used "decider" and used
it to describe a machine that decides whether to accept a formula as a specimen of the set of formulas described by a given grammar or whether
to reject it as specimen of the set?
Do you also mean to say that "decider" is elementary without reference
to grammars and specimens of their matches? Don't you agree that it is ambiguous as an term in an elementary principle due to the ordinary
meaning of "decider" being to classify a specimen one of two classes (a specimen being as general as even "the current state of the world" and
the classes being as correspondingly general as its suitability to
respond with one plan or another)?
I am concerned that the semantic ambiguity is particularly awkward
because the untrained reader will take "decider" in the ordinary sense
and take the principle already stated as a philosophical perspective on
its nature; the reader will not backtrack to the correct reading soon
enough to prevent misunderstanding. They will not settle on the intended reading which is instead to /define/ the term-of-art "decider" vis-a-vis
the grammar-matching sense. That will cause the population of readers to adopt acceptance and rejection as classes for the first sense when such specificity is not /correct/ for that sense.
On 20/12/2025 23:14, Richard Damon wrote:
On 12/20/25 6:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded labels for >>>>> the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of
sentences matching a defined language, and they are to ACCEPT strings
that match that grammar, and REJECT statements that fail to meet the
grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes
might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting actual >>> programs instead of merely characterising them, whether Olcott is doing
the politics or is being nudged by search results into effecting another >>> group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any
formal meaning in logistic philosophy is almost diluted away.
The use of the term "Halt Decider" and "Turing Machine" focus the
context fairly well. Add in his rambling about the Halting Problem, and
it seems clear.
Of course, it does also show is limited understanding, as deciders only
answering Accept or Reject is a somewhat limited space in that field,
but was the initial field which used the term.
Do you mean to say that Computation Theory first used "decider" and used
it to describe a machine that decides whether to accept a formula as a specimen of the set of formulas described by a given grammar or whether
to reject it as specimen of the set?
Do you also mean to say that "decider" is elementary without reference
to grammars and specimens of their matches? Don't you agree that it is ambiguous as an term in an elementary principle due to the ordinary
meaning of "decider" being to classify a specimen one of two classes (a specimen being as general as even "the current state of the world" and
the classes being as correspondingly general as its suitability to
respond with one plan or another)?
I am concerned that the semantic ambiguity is particularly awkward
because the untrained reader will take "decider" in the ordinary sense
and take the principle already stated as a philosophical perspective on
its nature; the reader will not backtrack to the correct reading soon
enough to prevent misunderstanding. They will not settle on the intended reading which is instead to /define/ the term-of-art "decider" vis-a-vis
the grammar-matching sense. That will cause the population of readers to adopt acceptance and rejection as classes for the first sense when such specificity is not /correct/ for that sense.
On 12/20/2025 8:16 PM, Tristan Wibberley wrote:
On 20/12/2025 23:14, Richard Damon wrote:
On 12/20/25 6:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of >>>>> sentences matching a defined language, and they are to ACCEPT strings >>>>> that match that grammar, and REJECT statements that fail to meet the >>>>> grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes
might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting
actual
programs instead of merely characterising them, whether Olcott is doing >>>> the politics or is being nudged by search results into effecting
another
group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any
formal meaning in logistic philosophy is almost diluted away.
The use of the term "Halt Decider" and "Turing Machine" focus the
context fairly well. Add in his rambling about the Halting Problem, and
it seems clear.
Of course, it does also show is limited understanding, as deciders only
answering Accept or Reject is a somewhat limited space in that field,
but was the initial field which used the term.
Do you mean to say that Computation Theory first used "decider" and used
it to describe a machine that decides whether to accept a formula as a
specimen of the set of formulas described by a given grammar or whether
to reject it as specimen of the set?
Do you also mean to say that "decider" is elementary without reference
to grammars and specimens of their matches? Don't you agree that it is
ambiguous as an term in an elementary principle due to the ordinary
meaning of "decider" being to classify a specimen one of two classes (a
specimen being as general as even "the current state of the world" and
the classes being as correspondingly general as its suitability to
respond with one plan or another)?
I am concerned that the semantic ambiguity is particularly awkward
because the untrained reader will take "decider" in the ordinary sense
and take the principle already stated as a philosophical perspective on
its nature; the reader will not backtrack to the correct reading soon
enough to prevent misunderstanding. They will not settle on the intended
reading which is instead to /define/ the term-of-art "decider" vis-a-vis
the grammar-matching sense. That will cause the population of readers to
adopt acceptance and rejection as classes for the first sense when such
specificity is not /correct/ for that sense.
It seems to me that in the broadest computational sense
that a decider is intended to address decision problems.
In computability theory and computational complexity
theory, a decision problem is a computational problem
that can be posed as a yes–no question on a set of input
values.
https://en.wikipedia.org/wiki/Decision_problem
Yet can only do so by
Transforming finite string inputs by finite
string transformation rules into Boolean Values.
In the broadest sense my 28 years of primary
research has focused on undecidability.
On 12/20/25 7:01 PM, olcott wrote:
On 12/20/2025 5:55 PM, Richard Damon wrote:
On 12/20/25 6:37 PM, olcott wrote:
On 12/20/2025 5:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of >>>>>> sentences matching a defined language, and they are to ACCEPT strings >>>>>> that match that grammar, and REJECT statements that fail to meet the >>>>>> grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
Not at all. I intentionally made it model free.
It uniformly applies to all models.
Nope, but then because of your self-imposed ignorance, you don't
understand the overloading of the term model.
Yes, the terminolgy works over different processing models of
computation, like Turing Machine, RASP machines, etc.
But another meaning is classifications of problems to handle.
Accept/Reject results come out of the model of questions which are
identifying if a given string matches a specificed language/grammar
where either the string does or does not meet the requirements. In
such a model, all Functions being computed have a boolean result.
Is there any other term besides accept/reject for
the subset of decision problems that are deciders?
Sure, for the broader model of deciders just being defined as a
algorithm that always halts, it is the full range of values it can produce.
On 12/20/25 9:33 PM, olcott wrote:
On 12/20/2025 8:16 PM, Tristan Wibberley wrote:
On 20/12/2025 23:14, Richard Damon wrote:
On 12/20/25 6:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of >>>>>> sentences matching a defined language, and they are to ACCEPT strings >>>>>> that match that grammar, and REJECT statements that fail to meet the >>>>>> grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes >>>>> might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting
actual
programs instead of merely characterising them, whether Olcott is
doing
the politics or is being nudged by search results into effecting
another
group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any >>>>> formal meaning in logistic philosophy is almost diluted away.
The use of the term "Halt Decider" and "Turing Machine" focus the
context fairly well. Add in his rambling about the Halting Problem, and >>>> it seems clear.
Of course, it does also show is limited understanding, as deciders only >>>> answering Accept or Reject is a somewhat limited space in that field,
but was the initial field which used the term.
Do you mean to say that Computation Theory first used "decider" and used >>> it to describe a machine that decides whether to accept a formula as a
specimen of the set of formulas described by a given grammar or whether
to reject it as specimen of the set?
Do you also mean to say that "decider" is elementary without reference
to grammars and specimens of their matches? Don't you agree that it is
ambiguous as an term in an elementary principle due to the ordinary
meaning of "decider" being to classify a specimen one of two classes (a
specimen being as general as even "the current state of the world" and
the classes being as correspondingly general as its suitability to
respond with one plan or another)?
I am concerned that the semantic ambiguity is particularly awkward
because the untrained reader will take "decider" in the ordinary sense
and take the principle already stated as a philosophical perspective on
its nature; the reader will not backtrack to the correct reading soon
enough to prevent misunderstanding. They will not settle on the intended >>> reading which is instead to /define/ the term-of-art "decider" vis-a-vis >>> the grammar-matching sense. That will cause the population of readers to >>> adopt acceptance and rejection as classes for the first sense when such
specificity is not /correct/ for that sense.
It seems to me that in the broadest computational sense
that a decider is intended to address decision problems.
That is one sub-space you can work in.
The term has also be overloaded as a term-of-art to more general cases, where the results can be part of a countable-infinite class.
In computability theory and computational complexity
theory, a decision problem is a computational problem
that can be posed as a yes–no question on a set of input
values.
https://en.wikipedia.org/wiki/Decision_problem
Yes, that is for DECISION problems, but deciders can be used for more
than decision problems in the more general parts of the theory.
Yet can only do so by
Transforming finite string inputs by finite
string transformation rules into Boolean Values.
Right, and that transformation needs to match the Function they are
trying to compute, which might be uncomputable
In the broadest sense my 28 years of primary
research has focused on undecidability.
Which in a broader sense isn't just on decision problems. But, if you
want to restrict yourself to just "Decison Problems" that is ok.
Yes, the Halting Problem IS a decision problem, and thus has only a
binary result.
A result that can't always be achieved by a finite deterministic
algrotihm in finite steps, and thus the problem is uncomputable.
Which doesn't make it invalid, just impossible to make a full Halt
Decider that always gives the right answer.
On 12/20/25 7:03 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few
minutes of searching. It is basic material in Computation Theory in >>>>> the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
Which begins:
Question: If a TM is given a string, what can happen to the computation? >>>
Answer: The machine can either
1. Accept the string (ie enter the Accept state and halt the
computation)
2. Reject the string (ie enter the Reject state and halt the
computation)
3. Enter an Infinite Loop (ie the computation never ends)
Thus introducing the idea that machines can accept or reject the input.
Where on Earth can you find that this must be
anchored in finite string transformation rules?
Because that is what Computations do.
And, if you aren't fixing your model to Turing Machines, it doesn't need
to be finite strings, but can be other types of representations.
On 12/20/25 6:40 PM, olcott wrote:
On 12/20/2025 5:14 PM, Richard Damon wrote:
On 12/20/25 6:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of >>>>> sentences matching a defined language, and they are to ACCEPT strings >>>>> that match that grammar, and REJECT statements that fail to meet the >>>>> grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes
might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting
actual
programs instead of merely characterising them, whether Olcott is doing >>>> the politics or is being nudged by search results into effecting
another
group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any
formal meaning in logistic philosophy is almost diluted away.
The use of the term "Halt Decider" and "Turing Machine" focus the
context fairly well. Add in his rambling about the Halting Problem,
and it seems clear.
Of course, it does also show is limited understanding, as deciders
only answering Accept or Reject is a somewhat limited space in that
field, but was the initial field which used the term.
It is the semantics of accept and reject no matter
what they are called or how they are encoded. Also
the model of computation makes no difference.
But some deciders map to more than just two output value.
For instance, an addition decider (like your sum function) can produce
any finte number as its output.
On 12/20/25 6:45 PM, olcott wrote:
On 12/20/2025 5:32 PM, Richard Damon wrote:
On 12/20/25 6:25 PM, olcott wrote:
On 12/20/2025 4:57 PM, Tristan Wibberley wrote:
On 20/12/2025 13:12, olcott wrote:
On 12/20/2025 7:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is not any sort of actual rebuttal
it is merely a dogmatic assertion. Actual
rebuttals (even incorrect ones) require reasoning.
I gave it to you before, I think.
It is categorically impossible for this to be
incorrect:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
No, you are categorically incorrect. While they may only USE a finite
string transformation, they are accoutable to the function they are
supposed to be computing.
They cannot be held accountable for any behavior
outside the scope of deciders as I have carefully
defined them. They cannot be required to bake
birthday cakes or use any psychic ability.
All that they can be required to do is transform
input finite strings into values.
And the scope of a decider is to attempt to compute the specified
mapping of input to output.
Since the mapping of a description of a Machine to whether that machine halts when run is a fully defined function/mapping, it is in scope for a decider.
It just can't be done, as that mapping is uncomputable, but that doesn't
put it out of scope.
Now, part of your problem is you don't understand that your decider has
a definite algorithm, and thus has a defined output for every input, and that is built on determinism, and not rules like "get the right answer".
Thus, this specific P CAN determine the results your SPECIFIC H will
give with itself as the input, and then do the opposite.
That make that H wrong, it doesn't make the answer a contradiction.--
It only makes the assumption that the decider as a Halt Decider an error.
On 12/20/2025 6:42 PM, Richard Damon wrote:
On 12/20/25 6:45 PM, olcott wrote:
On 12/20/2025 5:32 PM, Richard Damon wrote:
On 12/20/25 6:25 PM, olcott wrote:
On 12/20/2025 4:57 PM, Tristan Wibberley wrote:
On 20/12/2025 13:12, olcott wrote:
On 12/20/2025 7:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is not any sort of actual rebuttal
it is merely a dogmatic assertion. Actual
rebuttals (even incorrect ones) require reasoning.
I gave it to you before, I think.
It is categorically impossible for this to be
incorrect:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
No, you are categorically incorrect. While they may only USE a
finite string transformation, they are accoutable to the function
they are supposed to be computing.
They cannot be held accountable for any behavior
outside the scope of deciders as I have carefully
defined them. They cannot be required to bake
birthday cakes or use any psychic ability.
All that they can be required to do is transform
input finite strings into values.
And the scope of a decider is to attempt to compute the specified
mapping of input to output.
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
The input must somehow encode the value to be computed.
If it does not then the requirement is incorrect.
Since the mapping of a description of a Machine to whether that
machine halts when run is a fully defined function/mapping, it is in
scope for a decider.
You keep dodging this question.
By what correct finite string transformation rule
can HHH(DD) transform its input into the behavior
of DD simulated by HHH1?
It just can't be done, as that mapping is uncomputable, but that
doesn't put it out of scope.
Requiring to compute a mapping that does not exist
puts it out of scope.
Now, part of your problem is you don't understand that your decider
has a definite algorithm, and thus has a defined output for every
input, and that is built on determinism, and not rules like "get the
right answer".
I have had fully operational software for more than three years.
Thus, this specific P CAN determine the results your SPECIFIC H will
give with itself as the input, and then do the opposite.
If there is no mapping from the input to the required
value then the requirement is incorrect because it is
requires behavior that is out-of-scope for computation.
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
Requiring them to do more than that is an incorrect
requirement.
When-so-ever there are no finite string transformations
from an input into a required value the requirement is
out-of-scope for computation.
That make that H wrong, it doesn't make the answer a contradiction.
It only makes the assumption that the decider as a Halt Decider an error.
On 12/20/2025 6:42 PM, Richard Damon wrote:
On 12/20/25 6:40 PM, olcott wrote:
On 12/20/2025 5:14 PM, Richard Damon wrote:
On 12/20/25 6:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are determinators of >>>>>> sentences matching a defined language, and they are to ACCEPT strings >>>>>> that match that grammar, and REJECT statements that fail to meet the >>>>>> grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes >>>>> might barely do the trick but without the computational-linguistics
context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting
actual
programs instead of merely characterising them, whether Olcott is
doing
the politics or is being nudged by search results into effecting
another
group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string"
which is highly ambiguous in the context of computation such that any >>>>> formal meaning in logistic philosophy is almost diluted away.
The use of the term "Halt Decider" and "Turing Machine" focus the
context fairly well. Add in his rambling about the Halting Problem,
and it seems clear.
Of course, it does also show is limited understanding, as deciders
only answering Accept or Reject is a somewhat limited space in that
field, but was the initial field which used the term.
It is the semantics of accept and reject no matter
what they are called or how they are encoded. Also
the model of computation makes no difference.
But some deciders map to more than just two output value.
Where in any textbook does it say that?
For instance, an addition decider (like your sum function) can produce
any finte number as its output.
That is not an addition decider it is the computable function of sum.
On 12/20/2025 6:43 PM, Richard Damon wrote:
On 12/20/25 7:01 PM, olcott wrote:
On 12/20/2025 5:55 PM, Richard Damon wrote:
On 12/20/25 6:37 PM, olcott wrote:
On 12/20/2025 5:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are
determinators of
sentences matching a defined language, and they are to ACCEPT
strings
that match that grammar, and REJECT statements that fail to meet the >>>>>>> grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
Not at all. I intentionally made it model free.
It uniformly applies to all models.
Nope, but then because of your self-imposed ignorance, you don't
understand the overloading of the term model.
Yes, the terminolgy works over different processing models of
computation, like Turing Machine, RASP machines, etc.
But another meaning is classifications of problems to handle.
Accept/Reject results come out of the model of questions which are
identifying if a given string matches a specificed language/grammar
where either the string does or does not meet the requirements. In
such a model, all Functions being computed have a boolean result.
Is there any other term besides accept/reject for
the subset of decision problems that are deciders?
Sure, for the broader model of deciders just being defined as a
algorithm that always halts, it is the full range of values it can
produce.
In computability theory, a decider is a Turing
machine that halts for every input. https://en.wikipedia.org/wiki/Decider_(Turing_machine)
If it just stops running how can we tell what it decided?
On 12/20/2025 6:42 PM, Richard Damon wrote:
On 12/20/25 7:03 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded >>>>>>>>> labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few
minutes of searching. It is basic material in Computation Theory
in the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
Which begins:
Question: If a TM is given a string, what can happen to the
computation?
Answer: The machine can either
1. Accept the string (ie enter the Accept state and halt the
computation)
2. Reject the string (ie enter the Reject state and halt the
computation)
3. Enter an Infinite Loop (ie the computation never ends)
Thus introducing the idea that machines can accept or reject the input. >>>>
Where on Earth can you find that this must be
anchored in finite string transformation rules?
Because that is what Computations do.
I know that, you know that. What computer science textbook says that?
And, if you aren't fixing your model to Turing Machines, it doesn't
need to be finite strings, but can be other types of representations.
How so?
On 12/20/2025 8:57 PM, Richard Damon wrote:
On 12/20/25 9:33 PM, olcott wrote:
On 12/20/2025 8:16 PM, Tristan Wibberley wrote:
On 20/12/2025 23:14, Richard Damon wrote:
On 12/20/25 6:09 PM, Tristan Wibberley wrote:
On 20/12/2025 13:32, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
In ONE of the version of defining Deciders, they are
determinators of
sentences matching a defined language, and they are to ACCEPT
strings
that match that grammar, and REJECT statements that fail to meet the >>>>>>> grammar.
It's only valid in an elementary corpus of principle where the
correspondence is drawn such that the terms ACCEPT and REJECT are
characterised as references into that model and not just ordinary
English words. The capitalisation is not really enough; double-quotes >>>>>> might barely do the trick but without the computational-linguistics >>>>>> context it's really just politics. The politics is of nudging the
population of poorly educated readers into accepting or rejecting >>>>>> actual
programs instead of merely characterising them, whether Olcott is >>>>>> doing
the politics or is being nudged by search results into effecting
another
group's politics.
The only clues that the context is CompLang/AI within Olcott's
statements of principles themselves is the use of the word "string" >>>>>> which is highly ambiguous in the context of computation such that any >>>>>> formal meaning in logistic philosophy is almost diluted away.
The use of the term "Halt Decider" and "Turing Machine" focus the
context fairly well. Add in his rambling about the Halting Problem, >>>>> and
it seems clear.
Of course, it does also show is limited understanding, as deciders
only
answering Accept or Reject is a somewhat limited space in that field, >>>>> but was the initial field which used the term.
Do you mean to say that Computation Theory first used "decider" and
used
it to describe a machine that decides whether to accept a formula as a >>>> specimen of the set of formulas described by a given grammar or whether >>>> to reject it as specimen of the set?
Do you also mean to say that "decider" is elementary without reference >>>> to grammars and specimens of their matches? Don't you agree that it is >>>> ambiguous as an term in an elementary principle due to the ordinary
meaning of "decider" being to classify a specimen one of two classes (a >>>> specimen being as general as even "the current state of the world" and >>>> the classes being as correspondingly general as its suitability to
respond with one plan or another)?
I am concerned that the semantic ambiguity is particularly awkward
because the untrained reader will take "decider" in the ordinary sense >>>> and take the principle already stated as a philosophical perspective on >>>> its nature; the reader will not backtrack to the correct reading soon
enough to prevent misunderstanding. They will not settle on the
intended
reading which is instead to /define/ the term-of-art "decider" vis-
a-vis
the grammar-matching sense. That will cause the population of
readers to
adopt acceptance and rejection as classes for the first sense when such >>>> specificity is not /correct/ for that sense.
It seems to me that in the broadest computational sense
that a decider is intended to address decision problems.
That is one sub-space you can work in.
The term has also be overloaded as a term-of-art to more general
cases, where the results can be part of a countable-infinite class.
That would be a machine that never halts, thus out of scope.
In computability theory and computational complexity
theory, a decision problem is a computational problem
that can be posed as a yes–no question on a set of input
values.
https://en.wikipedia.org/wiki/Decision_problem
Yes, that is for DECISION problems, but deciders can be used for more
than decision problems in the more general parts of the theory.
Does this finite string contain: 111?
accept or yes for true reject or no for false.
Yet can only do so by
Transforming finite string inputs by finite
string transformation rules into Boolean Values.
Right, and that transformation needs to match the Function they are
trying to compute, which might be uncomputable
If the function cannot be computed from the input
then the input does not contain the value to be computed.
There is no magical way to compute the behavior
of DD simulated by HHH1 from DD simulated by HHH.
In the broadest sense my 28 years of primary
research has focused on undecidability.
Which in a broader sense isn't just on decision problems. But, if you
want to restrict yourself to just "Decison Problems" that is ok.
Yes, the Halting Problem IS a decision problem, and thus has only a
binary result.
A result that can't always be achieved by a finite deterministic
algrotihm in finite steps, and thus the problem is uncomputable.
Which doesn't make it invalid, just impossible to make a full Halt
Decider that always gives the right answer.
With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
On 21/12/2025 00:00, Richard Damon wrote:
With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
Which says:
"""
Recognizers and Deciders
A *recognizer* of a language is a machine that recognizes that language
A *decider* of a language is a machine that decides that language
"""
[boldening asterisks are mine to match the bold in the webpage]
It sets the context of the terms for its material as being for
languages; it has to to be okay.
While a Turing Machine instruction works on a tape with a finite string
on it, its "transformation" instructions are VERY limited, being write a
new value to the selected cell and move the tape one step in a specified direction.
On 21/12/2025 17:38, Richard Damon wrote:
While a Turing Machine instruction works on a tape with a finite string
on it, its "transformation" instructions are VERY limited, being write a
new value to the selected cell and move the tape one step in a specified
direction.
No I double checked Turing's 1936 paper. The transformation rule from
any state can be any finite sequence of steps derived from such atoms.
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few
minutes of searching. It is basic material in Computation Theory in
the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few
minutes of searching. It is basic material in Computation Theory in
the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few
minutes of searching. It is basic material in Computation Theory in
the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded
labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few
minutes of searching. It is basic material in Computation Theory in >>>>> the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String Transformation Rules".
So, don't expect that to come up.
Where did YOU get that as your basis?
I can guess, out of your ass, as that is the smartest part of you.
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded >>>>>>>>> labels for
the classes.
That is just one of the few accurate quotations Olcott makes.
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few
minutes of searching. It is basic material in Computation Theory
in the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String Transformation Rules".
Try to prove this. What counter-example do you have?
So, don't expect that to come up.
Where did YOU get that as your basis?
I can guess, out of your ass, as that is the smartest part of you.
It turns out that all
"true on the basis of meaning expressed in language"
for the entire body of knowledge
is verified by "finite string transformation rules"
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded >>>>>>>>>> labels for
the classes.
That is just one of the few accurate quotations Olcott makes. >>>>>>>>>
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few >>>>>>> minutes of searching. It is basic material in Computation Theory >>>>>>> in the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String Transformation Rules". >>>
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no strings at all, just a list of Numbers.
And even if you have a string based decider, just calling them "Transformation Rules" leaves too much ambiquity, as we can verbally describe rules that can not actually be computed, as you don't limit the "atoms" that make up your transformations.
This, it excludes cases that should be allowed, and allows things that should be exluded, and thus is a perfectly wrong definition.
So, don't expect that to come up.
Where did YOU get that as your basis?
I can guess, out of your ass, as that is the smartest part of you.
It turns out that all
"true on the basis of meaning expressed in language"
for the entire body of knowledge
is verified by "finite string transformation rules"
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded >>>>>>>>>>> labels for
the classes.
That is just one of the few accurate quotations Olcott makes. >>>>>>>>>>
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a few >>>>>>>> minutes of searching. It is basic material in Computation Theory >>>>>>>> in the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String Transformation
Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no strings at
all, just a list of Numbers.
And even if you have a string based decider, just calling them
"Transformation Rules" leaves too much ambiquity, as we can verbally
describe rules that can not actually be computed, as you don't limit
the "atoms" that make up your transformations.
This, it excludes cases that should be allowed, and allows things that
should be exluded, and thus is a perfectly wrong definition.
I need the simplest possible essence or I will
never be understood.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
So, don't expect that to come up.
Where did YOU get that as your basis?
I can guess, out of your ass, as that is the smartest part of you.
It turns out that all
"true on the basis of meaning expressed in language"
for the entire body of knowledge
is verified by "finite string transformation rules"
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally-loaded >>>>>>>>>>>> labels for
the classes.
That is just one of the few accurate quotations Olcott makes. >>>>>>>>>>>
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a >>>>>>>>> few minutes of searching. It is basic material in Computation >>>>>>>>> Theory in the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String Transformation
Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no strings at
all, just a list of Numbers.
And even if you have a string based decider, just calling them
"Transformation Rules" leaves too much ambiquity, as we can verbally
describe rules that can not actually be computed, as you don't limit
the "atoms" that make up your transformations.
This, it excludes cases that should be allowed, and allows things
that should be exluded, and thus is a perfectly wrong definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct.
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic.
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>> transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally- >>>>>>>>>>>>> loaded labels for
the classes.
That is just one of the few accurate quotations Olcott makes. >>>>>>>>>>>>
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a >>>>>>>>>> few minutes of searching. It is basic material in Computation >>>>>>>>>> Theory in the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String Transformation
Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no strings at
all, just a list of Numbers.
And even if you have a string based decider, just calling them
"Transformation Rules" leaves too much ambiquity, as we can verbally
describe rules that can not actually be computed, as you don't limit
the "atoms" that make up your transformations.
This, it excludes cases that should be allowed, and allows things
that should be exluded, and thus is a perfectly wrong definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct.
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic.
What is the error with that one?
On 12/21/25 7:59 PM, olcott wrote:
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>> transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally- >>>>>>>>>>>>>> loaded labels for
the classes.
That is just one of the few accurate quotations Olcott makes. >>>>>>>>>>>>>
It was not a quotation. I had to piece that together
myself from numerous sources. It took me 22 years to
do this.
Gee, that should be something you could have found in just a >>>>>>>>>>> few minutes of searching. It is basic material in Computation >>>>>>>>>>> Theory in the introductory material on Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html >>>>>>>>>
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String Transformation >>>>>>> Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no strings at >>>>> all, just a list of Numbers.
And even if you have a string based decider, just calling them
"Transformation Rules" leaves too much ambiquity, as we can
verbally describe rules that can not actually be computed, as you
don't limit the "atoms" that make up your transformations.
This, it excludes cases that should be allowed, and allows things
that should be exluded, and thus is a perfectly wrong definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct.
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic.
What is the error with that one?
That they are based on some arbitrary finite string transformation
rules. There are very specific requirements to the transformations that
they can do.
On 12/21/2025 7:07 PM, Richard Damon wrote:
On 12/21/25 7:59 PM, olcott wrote:
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally- >>>>>>>>>>>>>>> loaded labels for
the classes.
That is just one of the few accurate quotations Olcott makes. >>>>>>>>>>>>>>
It was not a quotation. I had to piece that together >>>>>>>>>>>>> myself from numerous sources. It took me 22 years to >>>>>>>>>>>>> do this.
Gee, that should be something you could have found in just a >>>>>>>>>>>> few minutes of searching. It is basic material in
Computation Theory in the introductory material on Deciders. >>>>>>>>>>>>
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html >>>>>>>>>>
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String Transformation >>>>>>>> Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no strings
at all, just a list of Numbers.
And even if you have a string based decider, just calling them
"Transformation Rules" leaves too much ambiquity, as we can
verbally describe rules that can not actually be computed, as you >>>>>> don't limit the "atoms" that make up your transformations.
This, it excludes cases that should be allowed, and allows things >>>>>> that should be exluded, and thus is a perfectly wrong definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct.
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic.
What is the error with that one?
That they are based on some arbitrary finite string transformation
rules. There are very specific requirements to the transformations
that they can do.
I never said arbitrary. I am only wrong
if they are sometimes not based on any
finite string transformation rules at all.
On 12/21/25 8:13 PM, olcott wrote:
On 12/21/2025 7:07 PM, Richard Damon wrote:
On 12/21/25 7:59 PM, olcott wrote:
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote:
On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}.
I continue to Reject your asymmetric and functionally- >>>>>>>>>>>>>>>> loaded labels for
the classes.
That is just one of the few accurate quotations Olcott >>>>>>>>>>>>>>> makes.
It was not a quotation. I had to piece that together >>>>>>>>>>>>>> myself from numerous sources. It took me 22 years to >>>>>>>>>>>>>> do this.
Gee, that should be something you could have found in just >>>>>>>>>>>>> a few minutes of searching. It is basic material in >>>>>>>>>>>>> Computation Theory in the introductory material on Deciders. >>>>>>>>>>>>>
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html >>>>>>>>>>>
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String
Transformation Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no strings >>>>>>> at all, just a list of Numbers.
And even if you have a string based decider, just calling them
"Transformation Rules" leaves too much ambiquity, as we can
verbally describe rules that can not actually be computed, as you >>>>>>> don't limit the "atoms" that make up your transformations.
This, it excludes cases that should be allowed, and allows things >>>>>>> that should be exluded, and thus is a perfectly wrong definition. >>>>>>>
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct.
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic.
What is the error with that one?
That they are based on some arbitrary finite string transformation
rules. There are very specific requirements to the transformations
that they can do.
I never said arbitrary. I am only wrong
if they are sometimes not based on any
finite string transformation rules at all.
You didn't restrict it, so you left it arbitary.
The "definition" of something needs to actualy define what it is.--
Defining a Playground ball as "A sphere" is incorect, as it allows many things that are not playground balls to be included.
And, Turing Machines are not describe in terms of "String
Transformations" except in very specific terms, so the definition is
just incorrect.
On 12/21/2025 7:45 PM, Richard Damon wrote:
On 12/21/25 8:13 PM, olcott wrote:
On 12/21/2025 7:07 PM, Richard Damon wrote:
On 12/21/25 7:59 PM, olcott wrote:
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote: >>>>>>>>>>>>>>>>> On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}. >>>>>>>>>>>>>>>>>I continue to Reject your asymmetric and functionally- >>>>>>>>>>>>>>>>> loaded labels for
the classes.
That is just one of the few accurate quotations Olcott >>>>>>>>>>>>>>>> makes.
It was not a quotation. I had to piece that together >>>>>>>>>>>>>>> myself from numerous sources. It took me 22 years to >>>>>>>>>>>>>>> do this.
Gee, that should be something you could have found in just >>>>>>>>>>>>>> a few minutes of searching. It is basic material in >>>>>>>>>>>>>> Computation Theory in the introductory material on Deciders. >>>>>>>>>>>>>>
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html >>>>>>>>>>>>
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String
Transformation Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no strings >>>>>>>> at all, just a list of Numbers.
And even if you have a string based decider, just calling them >>>>>>>> "Transformation Rules" leaves too much ambiquity, as we can
verbally describe rules that can not actually be computed, as >>>>>>>> you don't limit the "atoms" that make up your transformations. >>>>>>>>
This, it excludes cases that should be allowed, and allows
things that should be exluded, and thus is a perfectly wrong
definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct.
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic.
What is the error with that one?
That they are based on some arbitrary finite string transformation
rules. There are very specific requirements to the transformations
that they can do.
I never said arbitrary. I am only wrong
if they are sometimes not based on any
finite string transformation rules at all.
You didn't restrict it, so you left it arbitary.
Oh I see what you mean.
I never said anything about their intended purpose.
This was intentional.
If any intended purpose cannot be achieved by
applying finite string transformations to input
finite strings then the intended purpose is
outside of the scope of computation.
This is the entire essence of my 22 years of work
on the halting problem.
The "definition" of something needs to actualy define what it is.
Defining a Playground ball as "A sphere" is incorect, as it allows
many things that are not playground balls to be included.
And, Turing Machines are not describe in terms of "String
Transformations" except in very specific terms, so the definition is
just incorrect.
On 12/21/25 9:38 PM, olcott wrote:
On 12/21/2025 7:45 PM, Richard Damon wrote:
On 12/21/25 8:13 PM, olcott wrote:
On 12/21/2025 7:07 PM, Richard Damon wrote:
On 12/21/25 7:59 PM, olcott wrote:
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote:
On 12/20/25 8:01 AM, Tristan Wibberley wrote: >>>>>>>>>>>>>>>>>> On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}. >>>>>>>>>>>>>>>>>>I continue to Reject your asymmetric and functionally- >>>>>>>>>>>>>>>>>> loaded labels for
the classes.
That is just one of the few accurate quotations Olcott >>>>>>>>>>>>>>>>> makes.
It was not a quotation. I had to piece that together >>>>>>>>>>>>>>>> myself from numerous sources. It took me 22 years to >>>>>>>>>>>>>>>> do this.
Gee, that should be something you could have found in >>>>>>>>>>>>>>> just a few minutes of searching. It is basic material in >>>>>>>>>>>>>>> Computation Theory in the introductory material on Deciders. >>>>>>>>>>>>>>>
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html >>>>>>>>>>>>>
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String
Transformation Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no
strings at all, just a list of Numbers.
And even if you have a string based decider, just calling them >>>>>>>>> "Transformation Rules" leaves too much ambiquity, as we can >>>>>>>>> verbally describe rules that can not actually be computed, as >>>>>>>>> you don't limit the "atoms" that make up your transformations. >>>>>>>>>
This, it excludes cases that should be allowed, and allows
things that should be exluded, and thus is a perfectly wrong >>>>>>>>> definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct.
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic.
What is the error with that one?
That they are based on some arbitrary finite string transformation
rules. There are very specific requirements to the transformations
that they can do.
I never said arbitrary. I am only wrong
if they are sometimes not based on any
finite string transformation rules at all.
You didn't restrict it, so you left it arbitary.
Oh I see what you mean.
I never said anything about their intended purpose.
This was intentional.
If any intended purpose cannot be achieved by
applying finite string transformations to input
finite strings then the intended purpose is
outside of the scope of computation.
This is the entire essence of my 22 years of work
on the halting problem.
Which is just a factual error because you don't understand what the
terms mean.
They can only DO what can be done by their computations restrictions.
But the requirements are not limited by their ability, and it is
acknowledge that we can make requirements that can not be meet.
In fact, part of the goal of the field is to try to classify which types
of problems CAN be solved, and which can not.
Not understanding the purpose of the field means you are making fundamentally wrong assumptions.
On 12/21/2025 9:00 PM, Richard Damon wrote:
On 12/21/25 9:38 PM, olcott wrote:
On 12/21/2025 7:45 PM, Richard Damon wrote:
On 12/21/25 8:13 PM, olcott wrote:
On 12/21/2025 7:07 PM, Richard Damon wrote:
On 12/21/25 7:59 PM, olcott wrote:
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 12/20/25 8:01 AM, Tristan Wibberley wrote: >>>>>>>>>>>>>>>>>>> On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}. >>>>>>>>>>>>>>>>>>>I continue to Reject your asymmetric and >>>>>>>>>>>>>>>>>>> functionally- loaded labels for
the classes.
That is just one of the few accurate quotations Olcott >>>>>>>>>>>>>>>>>> makes.
It was not a quotation. I had to piece that together >>>>>>>>>>>>>>>>> myself from numerous sources. It took me 22 years to >>>>>>>>>>>>>>>>> do this.
Gee, that should be something you could have found in >>>>>>>>>>>>>>>> just a few minutes of searching. It is basic material in >>>>>>>>>>>>>>>> Computation Theory in the introductory material on >>>>>>>>>>>>>>>> Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3-Langs.html >>>>>>>>>>>>>>
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String
Transformation Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no
strings at all, just a list of Numbers.
And even if you have a string based decider, just calling them >>>>>>>>>> "Transformation Rules" leaves too much ambiquity, as we can >>>>>>>>>> verbally describe rules that can not actually be computed, as >>>>>>>>>> you don't limit the "atoms" that make up your transformations. >>>>>>>>>>
This, it excludes cases that should be allowed, and allows >>>>>>>>>> things that should be exluded, and thus is a perfectly wrong >>>>>>>>>> definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct.
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic.
What is the error with that one?
That they are based on some arbitrary finite string transformation >>>>>> rules. There are very specific requirements to the transformations >>>>>> that they can do.
I never said arbitrary. I am only wrong
if they are sometimes not based on any
finite string transformation rules at all.
You didn't restrict it, so you left it arbitary.
Oh I see what you mean.
I never said anything about their intended purpose.
This was intentional.
If any intended purpose cannot be achieved by
applying finite string transformations to input
finite strings then the intended purpose is
outside of the scope of computation.
This is the entire essence of my 22 years of work
on the halting problem.
Which is just a factual error because you don't understand what the
terms mean.
They can only DO what can be done by their computations restrictions.
But the requirements are not limited by their ability, and it is
acknowledge that we can make requirements that can not be meet.
In fact, part of the goal of the field is to try to classify which
types of problems CAN be solved, and which can not.
Not understanding the purpose of the field means you are making
fundamentally wrong assumptions.
I spent 22 years on the notion of undecidability.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
What-so-ever result that cannot be derived by
applying finite string transformation rules to
input finite strings <is> outside the scope of
computation.
On 12/21/25 10:19 PM, olcott wrote:No that is simply you not paying 100% complete
On 12/21/2025 9:00 PM, Richard Damon wrote:
On 12/21/25 9:38 PM, olcott wrote:
On 12/21/2025 7:45 PM, Richard Damon wrote:
On 12/21/25 8:13 PM, olcott wrote:
On 12/21/2025 7:07 PM, Richard Damon wrote:
On 12/21/25 7:59 PM, olcott wrote:
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote:
On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 12/20/25 8:01 AM, Tristan Wibberley wrote: >>>>>>>>>>>>>>>>>>>> On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}. >>>>>>>>>>>>>>>>>>>>I continue to Reject your asymmetric and >>>>>>>>>>>>>>>>>>>> functionally- loaded labels for
the classes.
That is just one of the few accurate quotations >>>>>>>>>>>>>>>>>>> Olcott makes.
It was not a quotation. I had to piece that together >>>>>>>>>>>>>>>>>> myself from numerous sources. It took me 22 years to >>>>>>>>>>>>>>>>>> do this.
Gee, that should be something you could have found in >>>>>>>>>>>>>>>>> just a few minutes of searching. It is basic material >>>>>>>>>>>>>>>>> in Computation Theory in the introductory material on >>>>>>>>>>>>>>>>> Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3- >>>>>>>>>>>>>>> Langs.html
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String
Transformation Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no >>>>>>>>>>> strings at all, just a list of Numbers.
And even if you have a string based decider, just calling >>>>>>>>>>> them "Transformation Rules" leaves too much ambiquity, as we >>>>>>>>>>> can verbally describe rules that can not actually be
computed, as you don't limit the "atoms" that make up your >>>>>>>>>>> transformations.
This, it excludes cases that should be allowed, and allows >>>>>>>>>>> things that should be exluded, and thus is a perfectly wrong >>>>>>>>>>> definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct.
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic.
What is the error with that one?
That they are based on some arbitrary finite string
transformation rules. There are very specific requirements to the >>>>>>> transformations that they can do.
I never said arbitrary. I am only wrong
if they are sometimes not based on any
finite string transformation rules at all.
You didn't restrict it, so you left it arbitary.
Oh I see what you mean.
I never said anything about their intended purpose.
This was intentional.
If any intended purpose cannot be achieved by
applying finite string transformations to input
finite strings then the intended purpose is
outside of the scope of computation.
This is the entire essence of my 22 years of work
on the halting problem.
Which is just a factual error because you don't understand what the
terms mean.
They can only DO what can be done by their computations restrictions.
But the requirements are not limited by their ability, and it is
acknowledge that we can make requirements that can not be meet.
In fact, part of the goal of the field is to try to classify which
types of problems CAN be solved, and which can not.
Not understanding the purpose of the field means you are making
fundamentally wrong assumptions.
I spent 22 years on the notion of undecidability.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
What-so-ever result that cannot be derived by
applying finite string transformation rules to
input finite strings <is> outside the scope of
computation.
Which, since there *IS* a procedure to get the result from the string
(the real UTM),
On 12/21/2025 10:07 PM, Richard Damon wrote:
On 12/21/25 10:19 PM, olcott wrote:No that is simply you not paying 100% complete
On 12/21/2025 9:00 PM, Richard Damon wrote:
On 12/21/25 9:38 PM, olcott wrote:
On 12/21/2025 7:45 PM, Richard Damon wrote:
On 12/21/25 8:13 PM, olcott wrote:
On 12/21/2025 7:07 PM, Richard Damon wrote:
On 12/21/25 7:59 PM, olcott wrote:
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 12/20/25 8:01 AM, Tristan Wibberley wrote: >>>>>>>>>>>>>>>>>>>>> On 19/12/2025 23:01, olcott wrote:
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}. >>>>>>>>>>>>>>>>>>>>>I continue to Reject your asymmetric and >>>>>>>>>>>>>>>>>>>>> functionally- loaded labels for
the classes.
That is just one of the few accurate quotations >>>>>>>>>>>>>>>>>>>> Olcott makes.
It was not a quotation. I had to piece that together >>>>>>>>>>>>>>>>>>> myself from numerous sources. It took me 22 years to >>>>>>>>>>>>>>>>>>> do this.
Gee, that should be something you could have found in >>>>>>>>>>>>>>>>>> just a few minutes of searching. It is basic material >>>>>>>>>>>>>>>>>> in Computation Theory in the introductory material on >>>>>>>>>>>>>>>>>> Deciders.
They never ever phrase it exactly that way.
Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3- >>>>>>>>>>>>>>>> Langs.html
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
None say: "finite string transformation rules"
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String >>>>>>>>>>>>>> Transformation Rules".
Try to prove this. What counter-example do you have?
As I have said, a Decider built on a RASP machine has no >>>>>>>>>>>> strings at all, just a list of Numbers.
And even if you have a string based decider, just calling >>>>>>>>>>>> them "Transformation Rules" leaves too much ambiquity, as we >>>>>>>>>>>> can verbally describe rules that can not actually be
computed, as you don't limit the "atoms" that make up your >>>>>>>>>>>> transformations.
This, it excludes cases that should be allowed, and allows >>>>>>>>>>>> things that should be exluded, and thus is a perfectly wrong >>>>>>>>>>>> definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct.
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic.
What is the error with that one?
That they are based on some arbitrary finite string
transformation rules. There are very specific requirements to >>>>>>>> the transformations that they can do.
I never said arbitrary. I am only wrong
if they are sometimes not based on any
finite string transformation rules at all.
You didn't restrict it, so you left it arbitary.
Oh I see what you mean.
I never said anything about their intended purpose.
This was intentional.
If any intended purpose cannot be achieved by
applying finite string transformations to input
finite strings then the intended purpose is
outside of the scope of computation.
This is the entire essence of my 22 years of work
on the halting problem.
Which is just a factual error because you don't understand what the
terms mean.
They can only DO what can be done by their computations restrictions.
But the requirements are not limited by their ability, and it is
acknowledge that we can make requirements that can not be meet.
In fact, part of the goal of the field is to try to classify which
types of problems CAN be solved, and which can not.
Not understanding the purpose of the field means you are making
fundamentally wrong assumptions.
I spent 22 years on the notion of undecidability.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
What-so-ever result that cannot be derived by
applying finite string transformation rules to
input finite strings <is> outside the scope of
computation.
Which, since there *IS* a procedure to get the result from the string
(the real UTM),
attention to the exact meaning of every single word.
When LLMs make this same mistake and I tell them they
did not pay close enough attention they immediately
correct themselves.
On 12/21/25 11:24 PM, olcott wrote:
On 12/21/2025 10:07 PM, Richard Damon wrote:
On 12/21/25 10:19 PM, olcott wrote:No that is simply you not paying 100% complete
On 12/21/2025 9:00 PM, Richard Damon wrote:
On 12/21/25 9:38 PM, olcott wrote:
On 12/21/2025 7:45 PM, Richard Damon wrote:
On 12/21/25 8:13 PM, olcott wrote:
On 12/21/2025 7:07 PM, Richard Damon wrote:
On 12/21/25 7:59 PM, olcott wrote:
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:As I have said, a Decider built on a RASP machine has no >>>>>>>>>>>>> strings at all, just a list of Numbers.
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote:
On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 12/20/25 8:01 AM, Tristan Wibberley wrote: >>>>>>>>>>>>>>>>>>>>>> On 19/12/2025 23:01, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}. >>>>>>>>>>>>>>>>>>>>>>
I continue to Reject your asymmetric and >>>>>>>>>>>>>>>>>>>>>> functionally- loaded labels for
the classes.
That is just one of the few accurate quotations >>>>>>>>>>>>>>>>>>>>> Olcott makes.
It was not a quotation. I had to piece that together >>>>>>>>>>>>>>>>>>>> myself from numerous sources. It took me 22 years to >>>>>>>>>>>>>>>>>>>> do this.
Gee, that should be something you could have found in >>>>>>>>>>>>>>>>>>> just a few minutes of searching. It is basic material >>>>>>>>>>>>>>>>>>> in Computation Theory in the introductory material on >>>>>>>>>>>>>>>>>>> Deciders.
They never ever phrase it exactly that way. >>>>>>>>>>>>>>>>>> Look for yourself.
Really? With a very quick search I get to:
https://sites.radford.edu/~nokie/classes/420/Chap3- >>>>>>>>>>>>>>>>> Langs.html
None say: "finite string transformation rules" >>>>>>>>>>>>>>>> None say: "finite string transformation rules" >>>>>>>>>>>>>>>> None say: "finite string transformation rules" >>>>>>>>>>>>>>>> None say: "finite string transformation rules" >>>>>>>>>>>>>>>>
Rigth, because that is the part you have wrong.
Deciders don't need to be based on "Finite String >>>>>>>>>>>>>>> Transformation Rules".
Try to prove this. What counter-example do you have? >>>>>>>>>>>>>
And even if you have a string based decider, just calling >>>>>>>>>>>>> them "Transformation Rules" leaves too much ambiquity, as >>>>>>>>>>>>> we can verbally describe rules that can not actually be >>>>>>>>>>>>> computed, as you don't limit the "atoms" that make up your >>>>>>>>>>>>> transformations.
This, it excludes cases that should be allowed, and allows >>>>>>>>>>>>> things that should be exluded, and thus is a perfectly >>>>>>>>>>>>> wrong definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct. >>>>>>>>>>>
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic. >>>>>>>>>>>
What is the error with that one?
That they are based on some arbitrary finite string
transformation rules. There are very specific requirements to >>>>>>>>> the transformations that they can do.
I never said arbitrary. I am only wrong
if they are sometimes not based on any
finite string transformation rules at all.
You didn't restrict it, so you left it arbitary.
Oh I see what you mean.
I never said anything about their intended purpose.
This was intentional.
If any intended purpose cannot be achieved by
applying finite string transformations to input
finite strings then the intended purpose is
outside of the scope of computation.
This is the entire essence of my 22 years of work
on the halting problem.
Which is just a factual error because you don't understand what the >>>>> terms mean.
They can only DO what can be done by their computations restrictions. >>>>>
But the requirements are not limited by their ability, and it is
acknowledge that we can make requirements that can not be meet.
In fact, part of the goal of the field is to try to classify which
types of problems CAN be solved, and which can not.
Not understanding the purpose of the field means you are making
fundamentally wrong assumptions.
I spent 22 years on the notion of undecidability.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
What-so-ever result that cannot be derived by
applying finite string transformation rules to
input finite strings <is> outside the scope of
computation.
Which, since there *IS* a procedure to get the result from the string
(the real UTM),
attention to the exact meaning of every single word.
Your problem is you don't know the meaning of the words, as defined in
the context you are talking.
When LLMs make this same mistake and I tell them they
did not pay close enough attention they immediately
correct themselves.
Because they are just yes-men, and not sources of truth.
All you have done is gathered liars to your (the LLM) to tell you what--
you want to believe so you don't have to confront the truth.
That just lets you try to live in your world of lies.
On 12/22/2025 9:10 AM, Richard Damon wrote:
On 12/21/25 11:24 PM, olcott wrote:
On 12/21/2025 10:07 PM, Richard Damon wrote:
On 12/21/25 10:19 PM, olcott wrote:No that is simply you not paying 100% complete
On 12/21/2025 9:00 PM, Richard Damon wrote:
On 12/21/25 9:38 PM, olcott wrote:
On 12/21/2025 7:45 PM, Richard Damon wrote:
On 12/21/25 8:13 PM, olcott wrote:
On 12/21/2025 7:07 PM, Richard Damon wrote:
On 12/21/25 7:59 PM, olcott wrote:
On 12/21/2025 6:54 PM, Richard Damon wrote:
On 12/21/25 7:41 PM, olcott wrote:
On 12/21/2025 6:10 PM, Richard Damon wrote:
On 12/21/25 7:05 PM, olcott wrote:
On 12/21/2025 5:37 PM, Richard Damon wrote:As I have said, a Decider built on a RASP machine has no >>>>>>>>>>>>>> strings at all, just a list of Numbers.
On 12/21/25 5:39 PM, olcott wrote:
On 12/20/2025 6:00 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 12/20/25 6:47 PM, olcott wrote:
On 12/20/2025 5:34 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 12/20/25 6:28 PM, olcott wrote:
On 12/20/2025 7:32 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 12/20/25 8:01 AM, Tristan Wibberley wrote: >>>>>>>>>>>>>>>>>>>>>>> On 19/12/2025 23:01, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}. >>>>>>>>>>>>>>>>>>>>>>>
I continue to Reject your asymmetric and >>>>>>>>>>>>>>>>>>>>>>> functionally- loaded labels for
the classes.
That is just one of the few accurate quotations >>>>>>>>>>>>>>>>>>>>>> Olcott makes.
It was not a quotation. I had to piece that together >>>>>>>>>>>>>>>>>>>>> myself from numerous sources. It took me 22 years to >>>>>>>>>>>>>>>>>>>>> do this.
Gee, that should be something you could have found >>>>>>>>>>>>>>>>>>>> in just a few minutes of searching. It is basic >>>>>>>>>>>>>>>>>>>> material in Computation Theory in the introductory >>>>>>>>>>>>>>>>>>>> material on Deciders.
They never ever phrase it exactly that way. >>>>>>>>>>>>>>>>>>> Look for yourself.
Really? With a very quick search I get to: >>>>>>>>>>>>>>>>>>
https://sites.radford.edu/~nokie/classes/420/Chap3- >>>>>>>>>>>>>>>>>> Langs.html
None say: "finite string transformation rules" >>>>>>>>>>>>>>>>> None say: "finite string transformation rules" >>>>>>>>>>>>>>>>> None say: "finite string transformation rules" >>>>>>>>>>>>>>>>> None say: "finite string transformation rules" >>>>>>>>>>>>>>>>>
Rigth, because that is the part you have wrong. >>>>>>>>>>>>>>>>
Deciders don't need to be based on "Finite String >>>>>>>>>>>>>>>> Transformation Rules".
Try to prove this. What counter-example do you have? >>>>>>>>>>>>>>
And even if you have a string based decider, just calling >>>>>>>>>>>>>> them "Transformation Rules" leaves too much ambiquity, as >>>>>>>>>>>>>> we can verbally describe rules that can not actually be >>>>>>>>>>>>>> computed, as you don't limit the "atoms" that make up your >>>>>>>>>>>>>> transformations.
This, it excludes cases that should be allowed, and allows >>>>>>>>>>>>>> things that should be exluded, and thus is a perfectly >>>>>>>>>>>>>> wrong definition.
I need the simplest possible essence or I will
never be understood.
You need to start for FACTS or you will never be correct. >>>>>>>>>>>>
It seems you logic says Truth is optional.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
Nope. Starting with your error, and you DOOM your logic. >>>>>>>>>>>>
What is the error with that one?
That they are based on some arbitrary finite string
transformation rules. There are very specific requirements to >>>>>>>>>> the transformations that they can do.
I never said arbitrary. I am only wrong
if they are sometimes not based on any
finite string transformation rules at all.
You didn't restrict it, so you left it arbitary.
Oh I see what you mean.
I never said anything about their intended purpose.
This was intentional.
If any intended purpose cannot be achieved by
applying finite string transformations to input
finite strings then the intended purpose is
outside of the scope of computation.
This is the entire essence of my 22 years of work
on the halting problem.
Which is just a factual error because you don't understand what
the terms mean.
They can only DO what can be done by their computations restrictions. >>>>>>
But the requirements are not limited by their ability, and it is
acknowledge that we can make requirements that can not be meet.
In fact, part of the goal of the field is to try to classify which >>>>>> types of problems CAN be solved, and which can not.
Not understanding the purpose of the field means you are making
fundamentally wrong assumptions.
I spent 22 years on the notion of undecidability.
Turing machine deciders: Transform finite string
inputs by finite string transformation rules into
{Accept, Reject} values.
What-so-ever result that cannot be derived by
applying finite string transformation rules to
input finite strings <is> outside the scope of
computation.
Which, since there *IS* a procedure to get the result from the
string (the real UTM),
attention to the exact meaning of every single word.
Your problem is you don't know the meaning of the words, as defined in
the context you are talking.
When LLMs make this same mistake and I tell them they
did not pay close enough attention they immediately
correct themselves.
Because they are just yes-men, and not sources of truth.
Carol's question + my Prolog are a convincing combination https://www.researchgate.net/ publication/398953475_Carol's_question_my_Prolog_are_a_convincing_combination
All you have done is gathered liars to your (the LLM) to tell you what
you want to believe so you don't have to confront the truth.
That just lets you try to live in your world of lies.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,090 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 59:51:19 |
| Calls: | 13,948 |
| Calls today: | 1 |
| Files: | 187,035 |
| D/L today: |
2,695 files (773M bytes) |
| Messages: | 2,461,296 |