Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
olcott kirjoitti 12.12.2025 klo 6.01:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
The last thus is false. What clause before it claims is irrelevant to
the meaning of the term "category error". Therefore the conclusion is
not proven.
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a
representation of the machine in question,
On 12/12/2025 8:12 AM, Richard Damon wrote:
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a
representation of the machine in question,
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
On 12/12/25 9:29 AM, olcott wrote:
On 12/12/2025 8:12 AM, Richard Damon wrote:
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a
representation of the machine in question,
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
But, you seem to forget, that said finite string can fully contain the information needed to recreate that execution behavior, and thus that behavior is a valid target for a question to it.
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
No, it is measured by the results created by an ACTUAL UTM.
On 12/12/2025 8:35 AM, Richard Damon wrote:
On 12/12/25 9:29 AM, olcott wrote:
On 12/12/2025 8:12 AM, Richard Damon wrote:
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a
representation of the machine in question,
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
But, you seem to forget, that said finite string can fully contain the
information needed to recreate that execution behavior, and thus that
behavior is a valid target for a question to it.
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
No, it is measured by the results created by an ACTUAL UTM.
Principle 1: Turing machine deciders compute functions
from *finite string inputs* to {accept, reject} according
to whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite string inputs. *This key detail has been ignored*
On 12/12/25 10:04 AM, olcott wrote:
On 12/12/2025 8:35 AM, Richard Damon wrote:
On 12/12/25 9:29 AM, olcott wrote:
On 12/12/2025 8:12 AM, Richard Damon wrote:
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a
representation of the machine in question,
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
But, you seem to forget, that said finite string can fully contain
the information needed to recreate that execution behavior, and thus
that behavior is a valid target for a question to it.
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
No, it is measured by the results created by an ACTUAL UTM.
Principle 1: Turing machine deciders compute functions
from *finite string inputs* to {accept, reject} according
to whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite string inputs. *This key detail has been ignored*
But the finite string is a representation of the Turing Machine,
On 12/12/2025 10:31 AM, Richard Damon wrote:
On 12/12/25 10:04 AM, olcott wrote:
On 12/12/2025 8:35 AM, Richard Damon wrote:
On 12/12/25 9:29 AM, olcott wrote:
On 12/12/2025 8:12 AM, Richard Damon wrote:
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a
representation of the machine in question,
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
But, you seem to forget, that said finite string can fully contain
the information needed to recreate that execution behavior, and thus
that behavior is a valid target for a question to it.
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
No, it is measured by the results created by an ACTUAL UTM.
Principle 1: Turing machine deciders compute functions
from *finite string inputs* to {accept, reject} according
to whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite string inputs. *This key detail has been ignored*
But the finite string is a representation of the Turing Machine,
"representation" has always been way too vague of a term.
It is the actual sequence of steps specified by the input.
It is ONLY the actual sequence of steps encoded by the
finite string AS AN INPUT not in any other context.
When the halting problem requires more than this it is
a category error.
On 12/12/25 11:54 AM, polcott wrote:
On 12/12/2025 10:31 AM, Richard Damon wrote:
On 12/12/25 10:04 AM, olcott wrote:
On 12/12/2025 8:35 AM, Richard Damon wrote:
On 12/12/25 9:29 AM, olcott wrote:
On 12/12/2025 8:12 AM, Richard Damon wrote:
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a
representation of the machine in question,
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
But, you seem to forget, that said finite string can fully contain
the information needed to recreate that execution behavior, and
thus that behavior is a valid target for a question to it.
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
No, it is measured by the results created by an ACTUAL UTM.
Principle 1: Turing machine deciders compute functions
from *finite string inputs* to {accept, reject} according
to whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite string inputs. *This key detail has been ignored*
But the finite string is a representation of the Turing Machine,
"representation" has always been way too vague of a term.
Only because you don't understand what it means. That just shows your stupidity. Do you think the representation "25" is vague? (given the
proper context, just like the input to the machine needs to be
interpreted in the context of the machine).
Your stupidity doesn't make the term and the logic based on it invalid,
just your arguements about it.
It is the actual sequence of steps specified by the input.
Nope, the input is the complete representation of the algorithm of the machine,
It is ONLY the actual sequence of steps encoded by the
finite string AS AN INPUT not in any other context.
Right, and those steps are the full set of steps that the machine that
has been described WILL do when it is run.
On 12/12/2025 12:25 PM, Richard Damon wrote:
On 12/12/25 11:54 AM, polcott wrote:
On 12/12/2025 10:31 AM, Richard Damon wrote:
On 12/12/25 10:04 AM, olcott wrote:
On 12/12/2025 8:35 AM, Richard Damon wrote:
On 12/12/25 9:29 AM, olcott wrote:
On 12/12/2025 8:12 AM, Richard Damon wrote:
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a
representation of the machine in question,
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
But, you seem to forget, that said finite string can fully contain >>>>>> the information needed to recreate that execution behavior, and
thus that behavior is a valid target for a question to it.
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
No, it is measured by the results created by an ACTUAL UTM.
Principle 1: Turing machine deciders compute functions
from *finite string inputs* to {accept, reject} according
to whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite string inputs. *This key detail has been ignored*
But the finite string is a representation of the Turing Machine,
"representation" has always been way too vague of a term.
Only because you don't understand what it means. That just shows your
stupidity. Do you think the representation "25" is vague? (given the
proper context, just like the input to the machine needs to be
interpreted in the context of the machine).
Your stupidity doesn't make the term and the logic based on it
invalid, just your arguements about it.
It is the actual sequence of steps specified by the input.
Nope, the input is the complete representation of the algorithm of the
machine,
It is ONLY the actual sequence of steps encoded by the
finite string AS AN INPUT not in any other context.
Right, and those steps are the full set of steps that the machine that
has been described WILL do when it is run.
I am trying extra hard to do as Christ said and
love my enemies/adversaries.
The term-of-the-art describes also has a base meaning
that is far too vague. It comes for the other technical
term-of-the-art machine description. Description also
has a base meaning that is far too vague. The the base
meaning is so vague abstracts away crucial details.
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
On 12/12/25 2:35 PM, polcott wrote:
On 12/12/2025 12:25 PM, Richard Damon wrote:
On 12/12/25 11:54 AM, polcott wrote:
On 12/12/2025 10:31 AM, Richard Damon wrote:
On 12/12/25 10:04 AM, olcott wrote:
On 12/12/2025 8:35 AM, Richard Damon wrote:
On 12/12/25 9:29 AM, olcott wrote:
On 12/12/2025 8:12 AM, Richard Damon wrote:
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a >>>>>>>>> representation of the machine in question,
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
But, you seem to forget, that said finite string can fully
contain the information needed to recreate that execution
behavior, and thus that behavior is a valid target for a question >>>>>>> to it.
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
No, it is measured by the results created by an ACTUAL UTM.
Principle 1: Turing machine deciders compute functions
from *finite string inputs* to {accept, reject} according
to whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite string inputs. *This key detail has been ignored*
But the finite string is a representation of the Turing Machine,
"representation" has always been way too vague of a term.
Only because you don't understand what it means. That just shows your
stupidity. Do you think the representation "25" is vague? (given the
proper context, just like the input to the machine needs to be
interpreted in the context of the machine).
Your stupidity doesn't make the term and the logic based on it
invalid, just your arguements about it.
It is the actual sequence of steps specified by the input.
Nope, the input is the complete representation of the algorithm of
the machine,
It is ONLY the actual sequence of steps encoded by the
finite string AS AN INPUT not in any other context.
Right, and those steps are the full set of steps that the machine
that has been described WILL do when it is run.
I am trying extra hard to do as Christ said and
love my enemies/adversaries.
You are doing better. So, why don't you try to actually answer the
questions with actual FACTS and DEFINTIONS from the actual theory, not
you made up idea of what you think they mean.
The term-of-the-art describes also has a base meaning
that is far too vague. It comes for the other technical
term-of-the-art machine description. Description also
has a base meaning that is far too vague. The the base
meaning is so vague abstracts away crucial details.
But that base meaning doesn't apply, except to your lies.
Your problem is that you don't understand that terms use the meaning requried by the context they are used in, and here, "Representation" has
a precise meaning.
Your faulty idea that some other meaning could be used he, just shows
you don't actually believe in the concept of Semantics.
Your rejection of, while at the same time depending on, semantics, just shows how messed up your logic is.
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the algorthm used to generate those steps.
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the algorthm used
to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the algorthm used
to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that doesn't specify what steps happen, it specifies the logic used to generate the steps.
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the algorthm
used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that doesn't
specify what steps happen, it specifies the logic used to generate the
steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the algorthm
used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that doesn't
specify what steps happen, it specifies the logic used to generate
the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting you are
just a liar.
If it is, then how is C code or x86 instrutions code a valid input.
Those are not a "exact sequence of steps" that the machine goes through.
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the algorthm
used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that
doesn't specify what steps happen, it specifies the logic used to
generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting you
are just a liar.
If it is, then how is C code or x86 instrutions code a valid input.
Those are not a "exact sequence of steps" that the machine goes through.
You must keep forgetting the details that
I have already provided.
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the algorthm >>>>>>> used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that
doesn't specify what steps happen, it specifies the logic used to
generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting you
are just a liar.
If it is, then how is C code or x86 instrutions code a valid input.
Those are not a "exact sequence of steps" that the machine goes through. >>>
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you logic is broken.
On 12/12/2025 4:22 PM, Richard Damon wrote:
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the algorthm >>>>>>>> used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that
doesn't specify what steps happen, it specifies the logic used to >>>>>> generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting you
are just a liar.
If it is, then how is C code or x86 instrutions code a valid input.
Those are not a "exact sequence of steps" that the machine goes
through.
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you logic
is broken.
If you can't remind me then it seems that the
issue is you own lack of attention span. Feel
free to go back through what I said. If you
can't even go back through what I said then it
is definitely your own attention span.
On 12/12/25 5:36 PM, olcott wrote:If you can't remind me what I said even by
On 12/12/2025 4:22 PM, Richard Damon wrote:
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the
algorthm used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that
doesn't specify what steps happen, it specifies the logic used to >>>>>>> generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting you >>>>> are just a liar.
If it is, then how is C code or x86 instrutions code a valid input. >>>>> Those are not a "exact sequence of steps" that the machine goes
through.
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you logic
is broken.
If you can't remind me then it seems that the
issue is you own lack of attention span. Feel
free to go back through what I said. If you
can't even go back through what I said then it
is definitely your own attention span.
But I DO repeat my reasoning,
On 12/12/2025 4:56 PM, Richard Damon wrote:
On 12/12/25 5:36 PM, olcott wrote:If you can't remind me what I said even by
On 12/12/2025 4:22 PM, Richard Damon wrote:
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the
algorthm used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that >>>>>>>> doesn't specify what steps happen, it specifies the logic used >>>>>>>> to generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting
you are just a liar.
If it is, then how is C code or x86 instrutions code a valid
input. Those are not a "exact sequence of steps" that the machine >>>>>> goes through.
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you logic
is broken.
If you can't remind me then it seems that the
issue is you own lack of attention span. Feel
free to go back through what I said. If you
can't even go back through what I said then it
is definitely your own attention span.
But I DO repeat my reasoning,
going back through my messages then the issue
is your attention span and nothing else.
On 12/12/25 6:02 PM, polcott wrote:
On 12/12/2025 4:56 PM, Richard Damon wrote:
On 12/12/25 5:36 PM, olcott wrote:If you can't remind me what I said even by
On 12/12/2025 4:22 PM, Richard Damon wrote:
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the >>>>>>>>>>> algorthm used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that >>>>>>>>> doesn't specify what steps happen, it specifies the logic used >>>>>>>>> to generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting >>>>>>> you are just a liar.
If it is, then how is C code or x86 instrutions code a valid
input. Those are not a "exact sequence of steps" that the machine >>>>>>> goes through.
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you
logic is broken.
If you can't remind me then it seems that the
issue is you own lack of attention span. Feel
free to go back through what I said. If you
can't even go back through what I said then it
is definitely your own attention span.
But I DO repeat my reasoning,
going back through my messages then the issue
is your attention span and nothing else.
In other words, you are admitting you never said it, as you would
normally love to prove me wrong,
Also, apparently you are convinced there is a teapot in the asteroid
belt, as no one has proven it isn't there.
Sorry, you are just proving that you can't answer the basic question of
why your input doesn't meet the rules you now want to require of the input.
The only reason is you can't tell the difference between facts and imagination because nothing has real meaning to you.
Was this insanity the reason you didn't go to jail for the kiddie porn?
On 12/12/2025 3:08 PM, Richard Damon wrote:
Was this insanity the reason you didn't go to jail for the kiddie porn?
Almost has to be?
On 12/12/25 5:36 PM, olcott wrote:You cannot even look up and see what I said.
On 12/12/2025 4:22 PM, Richard Damon wrote:
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the
algorthm used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that
doesn't specify what steps happen, it specifies the logic used to >>>>>>> generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting you >>>>> are just a liar.
If it is, then how is C code or x86 instrutions code a valid input. >>>>> Those are not a "exact sequence of steps" that the machine goes
through.
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you logic
is broken.
If you can't remind me then it seems that the
issue is you own lack of attention span. Feel
free to go back through what I said. If you
can't even go back through what I said then it
is definitely your own attention span.
But I DO repeat my reasoning,
On 12/12/2025 4:56 PM, Richard Damon wrote:
On 12/12/25 5:36 PM, olcott wrote:You cannot even look up and see what I said.
On 12/12/2025 4:22 PM, Richard Damon wrote:
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the
algorthm used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that >>>>>>>> doesn't specify what steps happen, it specifies the logic used >>>>>>>> to generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting
you are just a liar.
If it is, then how is C code or x86 instrutions code a valid
input. Those are not a "exact sequence of steps" that the machine >>>>>> goes through.
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you logic
is broken.
If you can't remind me then it seems that the
issue is you own lack of attention span. Feel
free to go back through what I said. If you
can't even go back through what I said then it
is definitely your own attention span.
But I DO repeat my reasoning,
On 12/12/25 7:40 PM, polcott wrote:
On 12/12/2025 4:56 PM, Richard Damon wrote:
On 12/12/25 5:36 PM, olcott wrote:You cannot even look up and see what I said.
On 12/12/2025 4:22 PM, Richard Damon wrote:
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always
been a finite string that SPECIFIES (in its encoding)
an exact sequence of steps. The decider only has what
this finite string encodes as its only basis.
The string does not specify the steps, it specifies the >>>>>>>>>>> algorthm used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that >>>>>>>>> doesn't specify what steps happen, it specifies the logic used >>>>>>>>> to generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting >>>>>>> you are just a liar.
If it is, then how is C code or x86 instrutions code a valid
input. Those are not a "exact sequence of steps" that the machine >>>>>>> goes through.
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you
logic is broken.
If you can't remind me then it seems that the
issue is you own lack of attention span. Feel
free to go back through what I said. If you
can't even go back through what I said then it
is definitely your own attention span.
But I DO repeat my reasoning,
But that doesn't answer the question,
On 12/12/2025 6:53 PM, Richard Damon wrote:
On 12/12/25 7:40 PM, polcott wrote:
On 12/12/2025 4:56 PM, Richard Damon wrote:
On 12/12/25 5:36 PM, olcott wrote:You cannot even look up and see what I said.
On 12/12/2025 4:22 PM, Richard Damon wrote:
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always >>>>>>>>>>>>> been a finite string that SPECIFIES (in its encoding) >>>>>>>>>>>>> an exact sequence of steps. The decider only has what >>>>>>>>>>>>> this finite string encodes as its only basis.
The string does not specify the steps, it specifies the >>>>>>>>>>>> algorthm used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic?
If it was, how can you say your C code is a valid input? that >>>>>>>>>> doesn't specify what steps happen, it specifies the logic used >>>>>>>>>> to generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting >>>>>>>> you are just a liar.
If it is, then how is C code or x86 instrutions code a valid
input. Those are not a "exact sequence of steps" that the
machine goes through.
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you
logic is broken.
If you can't remind me then it seems that the
issue is you own lack of attention span. Feel
free to go back through what I said. If you
can't even go back through what I said then it
is definitely your own attention span.
But I DO repeat my reasoning,
But that doesn't answer the question,
I am not going to infinitely answer the same
question. I asked you to go look up what I
already said. I am going to assume that you
cannot do that, not merely that you will not
do that.
On 12/12/25 8:27 PM, polcott wrote:HHH can't see any behavior besides the behavior
On 12/12/2025 6:53 PM, Richard Damon wrote:
On 12/12/25 7:40 PM, polcott wrote:
On 12/12/2025 4:56 PM, Richard Damon wrote:
On 12/12/25 5:36 PM, olcott wrote:You cannot even look up and see what I said.
On 12/12/2025 4:22 PM, Richard Damon wrote:
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always >>>>>>>>>>>>>> been a finite string that SPECIFIES (in its encoding) >>>>>>>>>>>>>> an exact sequence of steps. The decider only has what >>>>>>>>>>>>>> this finite string encodes as its only basis.
The string does not specify the steps, it specifies the >>>>>>>>>>>>> algorthm used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic? >>>>>>>>>>>
If it was, how can you say your C code is a valid input? that >>>>>>>>>>> doesn't specify what steps happen, it specifies the logic >>>>>>>>>>> used to generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just admitting >>>>>>>>> you are just a liar.
If it is, then how is C code or x86 instrutions code a valid >>>>>>>>> input. Those are not a "exact sequence of steps" that the
machine goes through.
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you
logic is broken.
If you can't remind me then it seems that the
issue is you own lack of attention span. Feel
free to go back through what I said. If you
can't even go back through what I said then it
is definitely your own attention span.
But I DO repeat my reasoning,
But that doesn't answer the question,
I am not going to infinitely answer the same
question. I asked you to go look up what I
already said. I am going to assume that you
cannot do that, not merely that you will not
do that.
And I am telling you that I have looked at what you said, and it doesn't answer the question of HOW if the only input allowed is a specification
of the steps that are actually executed, and not just the algorithm used
to generate those steps,
On 12/12/2025 8:17 PM, Richard Damon wrote:
On 12/12/25 8:27 PM, polcott wrote:HHH can't see any behavior besides the behavior
On 12/12/2025 6:53 PM, Richard Damon wrote:
On 12/12/25 7:40 PM, polcott wrote:
On 12/12/2025 4:56 PM, Richard Damon wrote:
On 12/12/25 5:36 PM, olcott wrote:You cannot even look up and see what I said.
On 12/12/2025 4:22 PM, Richard Damon wrote:
On 12/12/25 5:07 PM, polcott wrote:
On 12/12/2025 3:59 PM, Richard Damon wrote:
On 12/12/25 4:33 PM, olcott wrote:
On 12/12/2025 3:09 PM, Richard Damon wrote:
On 12/12/25 3:55 PM, polcott wrote:
On 12/12/2025 1:47 PM, Richard Damon wrote:
On 12/12/25 2:35 PM, polcott wrote:
The input to a Turing machine halt decider has always >>>>>>>>>>>>>>> been a finite string that SPECIFIES (in its encoding) >>>>>>>>>>>>>>> an exact sequence of steps. The decider only has what >>>>>>>>>>>>>>> this finite string encodes as its only basis.
The string does not specify the steps, it specifies the >>>>>>>>>>>>>> algorthm used to generate those steps.
Counter-factual.
The string encoding directly specifies
an exact sequence of steps within the
model of computation.
Where do you get that? More of your zero-principle logic? >>>>>>>>>>>>
If it was, how can you say your C code is a valid input? >>>>>>>>>>>> that doesn't specify what steps happen, it specifies the >>>>>>>>>>>> logic used to generate the steps.
It is a string of bytes that specifies an
exact sequence of steps within a model of
computation.
HOW??? Your input isn't that, so I guess you are just
admitting you are just a liar.
If it is, then how is C code or x86 instrutions code a valid >>>>>>>>>> input. Those are not a "exact sequence of steps" that the >>>>>>>>>> machine goes through.
You must keep forgetting the details that
I have already provided.
Then remind me, because it seems you are just showing that you >>>>>>>> logic is broken.
If you can't remind me then it seems that the
issue is you own lack of attention span. Feel
free to go back through what I said. If you
can't even go back through what I said then it
is definitely your own attention span.
But I DO repeat my reasoning,
But that doesn't answer the question,
I am not going to infinitely answer the same
question. I asked you to go look up what I
already said. I am going to assume that you
cannot do that, not merely that you will not
do that.
And I am telling you that I have looked at what you said, and it
doesn't answer the question of HOW if the only input allowed is a
specification of the steps that are actually executed, and not just
the algorithm used to generate those steps,
of DD simulated by HHH.
Principle 1: Turing machine deciders compute functions^^^^^^^^^^^^^^^^
from finite strings to {accept, reject} according to
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
On 12/12/25 9:29 AM, olcott wrote:
On 12/12/2025 8:12 AM, Richard Damon wrote:
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a
representation of the machine in question,
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
But, you seem to forget, that said finite string can fully contain the information needed to recreate that execution behavior, and thus that behavior is a valid target for a question to it.
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
No, it is measured by the results created by an ACTUAL UTM.
On 12/12/2025 04:01, olcott wrote:
Principle 1: Turing machine deciders compute functions^^^^^^^^^^^^^^^^
from finite strings to {accept, reject} according to
"some binary classification"
however, {accept, reject implies a specific human purpose that is not intrinsic to the decider, so I think it's not appropriate for a general statement.
On 12/12/2025 14:27, olcott wrote:
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
I don't think that's true, a UTM-based halt decider may also use
properties of the finite string other than it's nominal contracta.
On 12/12/2025 10:36 PM, Tristan Wibberley wrote:
On 12/12/2025 04:01, olcott wrote:
Principle 1: Turing machine deciders compute functions^^^^^^^^^^^^^^^^
from finite strings to {accept, reject} according to
"some binary classification"
however, {accept, reject implies a specific human purpose that is not
intrinsic to the decider, so I think it's not appropriate for a general
statement.
It seemed to be the generic way to say this.
On 12/12/2025 2:56 AM, Mikko wrote:
olcott kirjoitti 12.12.2025 klo 6.01:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
The last thus is false. What clause before it claims is irrelevant to
the meaning of the term "category error". Therefore the conclusion is
not proven.
The halting problem requires reporting on the behavior
of an executing Turing machine. Turing machines only
take finite string inputs and not Turing machine inputs.
*This is the category error*
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
This eliminates the category error.
On 13/12/2025 05:08, polcott wrote:
On 12/12/2025 10:36 PM, Tristan Wibberley wrote:
On 12/12/2025 04:01, olcott wrote:
Principle 1: Turing machine deciders compute functions^^^^^^^^^^^^^^^^
from finite strings to {accept, reject} according to
"some binary classification"
however, {accept, reject implies a specific human purpose that is not
intrinsic to the decider, so I think it's not appropriate for a general
statement.
It seemed to be the generic way to say this.
It's wrong for the reasons I stated above. It's just a meme for politics.
Intuitively, a decider should be a Turing machine that given an input,
halts and either accepts or rejects, relaying its answer in one of many equivalent ways, such as halting at an ACCEPT or REJECT state, or
leaving its answer on the output tape. https://cs.stackexchange.com/questions/84433/what-is-decider
On 12/12/2025 10:43 PM, Tristan Wibberley wrote:
On 12/12/2025 14:27, olcott wrote:
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
I don't think that's true, a UTM-based halt decider may also use
properties of the finite string other than it's nominal contracta.
I have no idea what you are saying.
There is apparently only one way to determine
the behavior that the input specifies.
On 12/12/2025 04:01, olcott wrote:
Principle 1: Turing machine deciders compute functions^^^^^^^^^^^^^^^^
from finite strings to {accept, reject} according to
"some binary classification"
however, {accept, reject implies a specific human purpose that is not intrinsic to the decider, so I think it's not appropriate for a general statement.
olcott kirjoitti 12.12.2025 klo 16.27:
On 12/12/2025 2:56 AM, Mikko wrote:
olcott kirjoitti 12.12.2025 klo 6.01:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
The last thus is false. What clause before it claims is irrelevant to
the meaning of the term "category error". Therefore the conclusion is
not proven.
The halting problem requires reporting on the behavior
of an executing Turing machine. Turing machines only
take finite string inputs and not Turing machine inputs.
*This is the category error*
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
This eliminates the category error.
You can't elminate what didn't ever exist. Instead that simply
declares that you are not talking about the halting problem.
On 13/12/2025 05:08, polcott wrote:
Intuitively, a decider should be a Turing machine that given an input,
halts and either accepts or rejects, relaying its answer in one of many
equivalent ways, such as halting at an ACCEPT or REJECT state, or
leaving its answer on the output tape.
https://cs.stackexchange.com/questions/84433/what-is-decider
That's wrong. Intuitively, a decider makes some commitment relative to a process; which could be just what to begin trying out, or even just what
to "believe" for the moment for a personal decider in their personal continuum. Absent the process and the role that the decision shall play,
a (discrete) decision has to be absolute (there can be no meaning), so
the terminology must be interpreted as a mere classification.
Is "decider" a conventional terminology for something that analyses for
the specific purpose of a process that involves ostensible acceptance or ostensible rejection continuations specifically?
On 12/12/25 11:36 PM, Tristan Wibberley wrote:
On 12/12/2025 04:01, olcott wrote:
Principle 1: Turing machine deciders compute functions^^^^^^^^^^^^^^^^
from finite strings to {accept, reject} according to
"some binary classification"
however, {accept, reject implies a specific human purpose that is not
intrinsic to the decider, so I think it's not appropriate for a general
statement.
Perhaps you missed that the classic definition of a "Decider" was to
test if a string fit within a given "grammar"
The decider would "accept" machines that fit, and "reject" things that didn't.
THe "grammar" for the halting problem was if the string was a
description of a Turing Machine/Input that would halt.
Thus, his Principle 1 is a correct statement for THAT definition of
decider. There are others, going to the point that one definition is
that it is any machine that will always halt no matter what input you
give it. That is, it computes a complete function of all possible input
to some set of output tapes/final states.
On 12/12/2025 10:43 PM, Tristan Wibberley wrote:
I don't think that's true, a UTM-based halt decider may also use
properties of the finite string other than it's nominal contracta.
I have no idea what you are saying.
There is apparently only one way to determine
the behavior that the input specifies.
It seems like you are saying that testing whether or
not a finite string is a member is a set is mortally wrong.
On 12/12/25 11:36 PM, Tristan Wibberley wrote:
On 12/12/2025 04:01, olcott wrote:
Principle 1: Turing machine deciders compute functions^^^^^^^^^^^^^^^^
from finite strings to {accept, reject} according to
"some binary classification"
however, {accept, reject implies a specific human purpose that is not
intrinsic to the decider, so I think it's not appropriate for a general
statement.
Perhaps you missed that the classic definition of a "Decider" was to
test if a string fit within a given "grammar"
The decider would "accept" machines that fit, and "reject" things that didn't.
THe "grammar" for the halting problem was if the string was a
description of a Turing Machine/Input that would halt.
Thus, his Principle 1 is a correct statement for THAT definition of
decider. There are others, going to the point that one definition is
that it is any machine that will always halt no matter what input you
give it. That is, it computes a complete function of all possible input
to some set of output tapes/final states.
On 13/12/2025 05:10, polcott wrote:
On 12/12/2025 10:43 PM, Tristan Wibberley wrote:
I don't think that's true, a UTM-based halt decider may also use
properties of the finite string other than it's nominal contracta.
I have no idea what you are saying.
There is apparently only one way to determine
the behavior that the input specifies.
"contracta" latin plural of "contractum" (I think).
"contractum" the result of reducing a redex.
In a reduction system with transitive reduction (all those interesting
wrt to halting problems) a program is a redex of a reduction which has a contractum that is a redex of a reduction that has a contractum ... so I
say a program has many contracta. I say nominal contracta because a
physical TM won't always do as the assumptions programmed into the
deciding TM stipulate and I feel that gets the point across.
Simulation (sense of emulation/virtualisation) works by sequentially enumerating all the contracta.
Halt-deciding by simulation (sense of emulation/virtualisation) draws inferences from the contracta, but it may draw inferences from the
initial program that are, at least in part, not contracta of the initial program.
On 12/12/2025 14:35, Richard Damon wrote:
On 12/12/25 9:29 AM, olcott wrote:
On 12/12/2025 8:12 AM, Richard Damon wrote:
On 12/11/25 11:01 PM, olcott wrote:
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
The halting problem requires that a halt decider
report on the direct execution of a Turing machine,
thus category error.
Which is a semantic property of the string, assuming it is a
representation of the machine in question,
Principle 1: Turing machine deciders compute functions
from finite strings to {accept, reject} according to
whether the input has a syntactic property or specifies
a semantic property.
Turing machine deciders only report on the behavior
of Turing machines indirectly through the proxy of
finite strings. *This key detail has been ignored*
But, you seem to forget, that said finite string can fully contain the
information needed to recreate that execution behavior, and thus that
behavior is a valid target for a question to it.
No. The information required is:
1. the program (the finite string)
2. the reduction rules
The finite string only contains 1, because 2 is nonempty.
Principle 2: We measure the semantic property that
the finite string specifies by a UTM-based halt
decider that simulates its input finite string
step-by-step and watches the execution trace of
this behavior.
No, it is measured by the results created by an ACTUAL UTM.
no, it is measured by the results defined by the reduction rules. The statement that it has anything to do directly with an actual UTM (or TM)
is a misconception. Any physical, ostensible TMs (OTMs?) are
approximations of their respective reduction rules that, statistically,
are unlikely to deviate.
The problem is about physical computers only in as much as it elaborates
on what will happen in the limit of the process of creating ever more reliable TMs.
On 12/13/2025 7:58 AM, Tristan Wibberley wrote:
On 13/12/2025 05:08, polcott wrote:
Intuitively, a decider should be a Turing machine that given an input,
halts and either accepts or rejects, relaying its answer in one of many
equivalent ways, such as halting at an ACCEPT or REJECT state, or
leaving its answer on the output tape.
https://cs.stackexchange.com/questions/84433/what-is-decider
That's wrong. Intuitively, a decider makes some commitment relative to a
process; which could be just what to begin trying out, or even just what
to "believe" for the moment for a personal decider in their personal
continuum. Absent the process and the role that the decision shall play,
a (discrete) decision has to be absolute (there can be no meaning), so
the terminology must be interpreted as a mere classification.
Is "decider" a conventional terminology for something that analyses for
the specific purpose of a process that involves ostensible acceptance or
ostensible rejection continuations specifically?
Decider is a term-of-the-art of the theory of
computation. It simply decides whether or not
a finite string is a member of a set.
The screwy thing about the term-of-the-art is
that if it gets even one wrong answer it is
not any decider at all.
As a term-of-the-art a decider must be all knowing.
This is easy for syntactic properties. Much more
difficult for semantic properties.
All Turing machines only compute the mapping
from an input finite string to some value.
On 12/13/2025 8:35 AM, Richard Damon wrote:
On 12/12/25 11:36 PM, Tristan Wibberley wrote:
On 12/12/2025 04:01, olcott wrote:
Principle 1: Turing machine deciders compute functions^^^^^^^^^^^^^^^^
from finite strings to {accept, reject} according to
"some binary classification"
however, {accept, reject implies a specific human purpose that is not
intrinsic to the decider, so I think it's not appropriate for a general
statement.
Perhaps you missed that the classic definition of a "Decider" was to
test if a string fit within a given "grammar"
The decider would "accept" machines that fit, and "reject" things that
didn't.
THe "grammar" for the halting problem was if the string was a
description of a Turing Machine/Input that would halt.
Thus, his Principle 1 is a correct statement for THAT definition of
decider. There are others, going to the point that one definition is
that it is any machine that will always halt no matter what input you
give it. That is, it computes a complete function of all possible
input to some set of output tapes/final states.
At the most fundamental level:
All Turing machines only compute the mapping
from input finite strings to some value.
Turing machine Deciders are a subset of this such
that the value indicates accept or reject a finite
string by some criterion measure.
On 13/12/2025 14:35, Richard Damon wrote:
On 12/12/25 11:36 PM, Tristan Wibberley wrote:
On 12/12/2025 04:01, olcott wrote:
Principle 1: Turing machine deciders compute functions^^^^^^^^^^^^^^^^
from finite strings to {accept, reject} according to
"some binary classification"
however, {accept, reject implies a specific human purpose that is not
intrinsic to the decider, so I think it's not appropriate for a general
statement.
Perhaps you missed that the classic definition of a "Decider" was to
test if a string fit within a given "grammar"
Yes, I did.
The decider would "accept" machines that fit, and "reject" things that
didn't.
THe "grammar" for the halting problem was if the string was a
description of a Turing Machine/Input that would halt.
Is that a classic definition of "grammar", too? We're talking about
before Chomsky's hierarchy. If my memory serves, even after that there
isn't a definition of "grammar" that covers halting semantics is there?
Thus, his Principle 1 is a correct statement for THAT definition of
decider. There are others, going to the point that one definition is
that it is any machine that will always halt no matter what input you
give it. That is, it computes a complete function of all possible input
to some set of output tapes/final states.
I understood that "to decide" from the time was defined for propositions whereupon one classifies them true or false and that merely extends to
the proposition that "string X fits grammar Y". Not the other way around.
On 13/12/2025 14:35, Richard Damon wrote:
On 12/12/25 11:36 PM, Tristan Wibberley wrote:
On 12/12/2025 04:01, olcott wrote:
Principle 1: Turing machine deciders compute functions^^^^^^^^^^^^^^^^
from finite strings to {accept, reject} according to
"some binary classification"
however, {accept, reject implies a specific human purpose that is not
intrinsic to the decider, so I think it's not appropriate for a general
statement.
Perhaps you missed that the classic definition of a "Decider" was to
test if a string fit within a given "grammar"
Yes, I did.
The decider would "accept" machines that fit, and "reject" things that
didn't.
THe "grammar" for the halting problem was if the string was a
description of a Turing Machine/Input that would halt.
Is that a classic definition of "grammar", too? We're talking about
before Chomsky's hierarchy. If my memory serves, even after that there
isn't a definition of "grammar" that covers halting semantics is there?
Thus, his Principle 1 is a correct statement for THAT definition of
decider. There are others, going to the point that one definition is
that it is any machine that will always halt no matter what input you
give it. That is, it computes a complete function of all possible input
to some set of output tapes/final states.
I understood that "to decide" from the time was defined for propositions whereupon one classifies them true or false and that merely extends to
the proposition that "string X fits grammar Y". Not the other way around.
On 12/13/25 11:02 AM, olcott wrote:
On 12/13/2025 7:58 AM, Tristan Wibberley wrote:
On 13/12/2025 05:08, polcott wrote:
Intuitively, a decider should be a Turing machine that given an input, >>>> halts and either accepts or rejects, relaying its answer in one of many >>>> equivalent ways, such as halting at an ACCEPT or REJECT state, or
leaving its answer on the output tape.
https://cs.stackexchange.com/questions/84433/what-is-decider
That's wrong. Intuitively, a decider makes some commitment relative to a >>> process; which could be just what to begin trying out, or even just what >>> to "believe" for the moment for a personal decider in their personal
continuum. Absent the process and the role that the decision shall play, >>> a (discrete) decision has to be absolute (there can be no meaning), so
the terminology must be interpreted as a mere classification.
Is "decider" a conventional terminology for something that analyses for
the specific purpose of a process that involves ostensible acceptance or >>> ostensible rejection continuations specifically?
Decider is a term-of-the-art of the theory of
computation. It simply decides whether or not
a finite string is a member of a set.
The screwy thing about the term-of-the-art is
that if it gets even one wrong answer it is
not any decider at all.
Right, because it needs to CORRECTLY decide, after all, logic is about gettting the right answers.
As a term-of-the-art a decider must be all knowing.
This is easy for syntactic properties. Much more
difficult for semantic properties.
Only because it needs to get all answers correct.
If you think logic is allowed to get wrong answers, you don't understand
how logic works.
All Turing machines only compute the mapping
from an input finite string to some value.
Right, but to CORRECTLY be a machine to compute a specified function,
the mapping they generate needs to match that function for all values.
Thus, a Halt Decider, given a finite string that specifies a given
Turing Machine (and its input) needs to return the result of if that
machine will halt when it is run.
If its answer is ever wrong, it isn't a halt decider.
If you think things can be wrong at time, but still right, you are--
admitting that you accept that you logic is just inconsistant.
If its answer is ever wrong, it isn't a halt decider.
If you think things can be wrong at time, but still right, you are
admitting that you accept that you logic is just inconsistant.
Here is an insight that LLM Kimi suggested entirely
on the basis of the text of my first principles.
The Universal TM's Illusion: The UTM appears
to "simulate another machine," but it's really just
interpreting a string as a lookup table for state
transitions. The simulation is pure string rewriting.
On 12/13/2025 12:57 PM, Richard Damon wrote:
On 12/13/25 11:02 AM, olcott wrote:
On 12/13/2025 7:58 AM, Tristan Wibberley wrote:
On 13/12/2025 05:08, polcott wrote:
Intuitively, a decider should be a Turing machine that given an input, >>>>> halts and either accepts or rejects, relaying its answer in one of
many
equivalent ways, such as halting at an ACCEPT or REJECT state, or
leaving its answer on the output tape.
https://cs.stackexchange.com/questions/84433/what-is-decider
That's wrong. Intuitively, a decider makes some commitment relative
to a
process; which could be just what to begin trying out, or even just
what
to "believe" for the moment for a personal decider in their personal
continuum. Absent the process and the role that the decision shall
play,
a (discrete) decision has to be absolute (there can be no meaning), so >>>> the terminology must be interpreted as a mere classification.
Is "decider" a conventional terminology for something that analyses for >>>> the specific purpose of a process that involves ostensible
acceptance or
ostensible rejection continuations specifically?
Decider is a term-of-the-art of the theory of
computation. It simply decides whether or not
a finite string is a member of a set.
The screwy thing about the term-of-the-art is
that if it gets even one wrong answer it is
not any decider at all.
Right, because it needs to CORRECTLY decide, after all, logic is about
gettting the right answers.
As a term-of-the-art a decider must be all knowing.
This is easy for syntactic properties. Much more
difficult for semantic properties.
Only because it needs to get all answers correct.
If you think logic is allowed to get wrong answers, you don't
understand how logic works.
That is must have the actual mind-of-god
for programming seems too much. A partial
halt decider confuses the Hell out of newbies.
A halt decider over a specific domain is
the middle ground.
All Turing machines only compute the mapping
from an input finite string to some value.
Right, but to CORRECTLY be a machine to compute a specified function,
the mapping they generate needs to match that function for all values.
Thus, a Halt Decider, given a finite string that specifies a given
Turing Machine (and its input) needs to return the result of if that
machine will halt when it is run.
It must be the actual sequence of steps that
this finite string as an input actually specify.
I have gone over this with LLM systems and they
give me lots of push-back yet get it every time.
I have made my words so clear that the get it
in 10 pages rather than the 50 pages that it
used to take them.
If its answer is ever wrong, it isn't a halt decider.
Terms-of-the-art should never violate the base
meaning of the same term. This really hurts
effective communication.
We could have a term-of-the-art
"died five minutes ago"
mean that he is in excellent health and
passed all of his health tests.
Rule-out literally means to get a ruler and
draw a black line through some words indicating
that they are now excluded.
That mental health uses this term backwards of
the rest of the world is itself quite nuts.
A rule-out in mental health means that these
issues are still being considered.
If you think things can be wrong at time, but still right, you are
admitting that you accept that you logic is just inconsistant.
On 12/13/25 2:43 PM, olcott wrote:
Here is an insight that LLM Kimi suggested entirely
on the basis of the text of my first principles.
The Universal TM's Illusion: The UTM appears
to "simulate another machine," but it's really just
interpreting a string as a lookup table for state
transitions. The simulation is pure string rewriting.
Yes, Simulating a Turing Machine is just a series of string rewriting,
as that is what a Turing Machine does.
It is just a stateful string re-writer.
On 12/13/25 2:43 PM, olcott wrote:
Here is an insight that LLM Kimi suggested entirely
on the basis of the text of my first principles.
The Universal TM's Illusion: The UTM appears
to "simulate another machine," but it's really just
interpreting a string as a lookup table for state
transitions. The simulation is pure string rewriting.
Yes, Simulating a Turing Machine is just a series of string rewriting,
as that is what a Turing Machine does.
It is just a stateful string re-writer.
On 12/13/25 3:07 PM, olcott wrote:
On 12/13/2025 12:57 PM, Richard Damon wrote:
On 12/13/25 11:02 AM, olcott wrote:
On 12/13/2025 7:58 AM, Tristan Wibberley wrote:
On 13/12/2025 05:08, polcott wrote:
Intuitively, a decider should be a Turing machine that given an
input,
halts and either accepts or rejects, relaying its answer in one of >>>>>> many
equivalent ways, such as halting at an ACCEPT or REJECT state, or
leaving its answer on the output tape.
https://cs.stackexchange.com/questions/84433/what-is-decider
That's wrong. Intuitively, a decider makes some commitment relative >>>>> to a
process; which could be just what to begin trying out, or even just >>>>> what
to "believe" for the moment for a personal decider in their personal >>>>> continuum. Absent the process and the role that the decision shall
play,
a (discrete) decision has to be absolute (there can be no meaning), so >>>>> the terminology must be interpreted as a mere classification.
Is "decider" a conventional terminology for something that analyses >>>>> for
the specific purpose of a process that involves ostensible
acceptance or
ostensible rejection continuations specifically?
Decider is a term-of-the-art of the theory of
computation. It simply decides whether or not
a finite string is a member of a set.
The screwy thing about the term-of-the-art is
that if it gets even one wrong answer it is
not any decider at all.
Right, because it needs to CORRECTLY decide, after all, logic is
about gettting the right answers.
As a term-of-the-art a decider must be all knowing.
This is easy for syntactic properties. Much more
difficult for semantic properties.
Only because it needs to get all answers correct.
If you think logic is allowed to get wrong answers, you don't
understand how logic works.
That is must have the actual mind-of-god
for programming seems too much. A partial
halt decider confuses the Hell out of newbies.
A halt decider over a specific domain is
the middle ground.
But you are confused. Turing Machine have NO mind, they don't "know" anything, they just perform a mechanical operation.
It seems your problem is you just don't understand what you are talking about.
The "specific domain" for any general decider on Turing Machines is ALL Turing Machines.
Anything less, and you are just lying about what you are deciding on.
Yes, partial deciders that are able to always decide over a limited
range have SOME use, but don't solve the initial problem.
Such machines exist for many classes of sub-domains.
All Turing machines only compute the mapping
from an input finite string to some value.
Right, but to CORRECTLY be a machine to compute a specified function,
the mapping they generate needs to match that function for all values.
Thus, a Halt Decider, given a finite string that specifies a given
Turing Machine (and its input) needs to return the result of if that
machine will halt when it is run.
It must be the actual sequence of steps that
this finite string as an input actually specify.
Then none of your inputs meet this requirement, as none of you input
have STEPS in them, only instructions that will decide what steps to do.
I have gone over this with LLM systems and they
give me lots of push-back yet get it every time.
Yes, you have repeated this nonsense many times, but are unable to
explain how the fact that your definitions and you examples don't match
show you know anything.
I have made my words so clear that the get it
in 10 pages rather than the 50 pages that it
used to take them.
No, you are just showing you don't know what you words mean.
If its answer is ever wrong, it isn't a halt decider.
Terms-of-the-art should never violate the base
meaning of the same term. This really hurts
effective communication.
Then you don't understand the field of Semantics. Normally terms-of-art
are a REFINEMENT of the wider common definition, so tend not to
"violate" it.
We could have a term-of-the-art
"died five minutes ago"
mean that he is in excellent health and
passed all of his health tests.
That would be a bad term of art, but that isn't what terms-of-art do.
Your repeat use of bad examples just shows that you are ignorant of what
you are talking out.
Rule-out literally means to get a ruler and
draw a black line through some words indicating
that they are now excluded.
That mental health uses this term backwards of
the rest of the world is itself quite nuts.
A rule-out in mental health means that these
issues are still being considered.
So, are you that familiar with mental-health terminology? A guess that
would be natural for someone who may have a history of contact with them.
And, I think you don't understand the meaning of the term there. "A Rule-Out" is a process that eliminates some possibilities by a process
that determines that the can't exist.
The final condition(s) left are not called "rule-out" but are the
conditions left after the rule-out process.
Again, showing a lack of understanding of the terminology that you have heard and guessed its meaning.
If you think things can be wrong at time, but still right, you are
admitting that you accept that you logic is just inconsistant.
On 12/13/2025 2:22 PM, Richard Damon wrote:
On 12/13/25 3:07 PM, olcott wrote:
On 12/13/2025 12:57 PM, Richard Damon wrote:
On 12/13/25 11:02 AM, olcott wrote:
On 12/13/2025 7:58 AM, Tristan Wibberley wrote:
On 13/12/2025 05:08, polcott wrote:
Intuitively, a decider should be a Turing machine that given an >>>>>>> input,
halts and either accepts or rejects, relaying its answer in one >>>>>>> of many
equivalent ways, such as halting at an ACCEPT or REJECT state, or >>>>>>> leaving its answer on the output tape.
https://cs.stackexchange.com/questions/84433/what-is-decider
That's wrong. Intuitively, a decider makes some commitment
relative to a
process; which could be just what to begin trying out, or even
just what
to "believe" for the moment for a personal decider in their personal >>>>>> continuum. Absent the process and the role that the decision shall >>>>>> play,
a (discrete) decision has to be absolute (there can be no
meaning), so
the terminology must be interpreted as a mere classification.
Is "decider" a conventional terminology for something that
analyses for
the specific purpose of a process that involves ostensible
acceptance or
ostensible rejection continuations specifically?
Decider is a term-of-the-art of the theory of
computation. It simply decides whether or not
a finite string is a member of a set.
The screwy thing about the term-of-the-art is
that if it gets even one wrong answer it is
not any decider at all.
Right, because it needs to CORRECTLY decide, after all, logic is
about gettting the right answers.
As a term-of-the-art a decider must be all knowing.
This is easy for syntactic properties. Much more
difficult for semantic properties.
Only because it needs to get all answers correct.
If you think logic is allowed to get wrong answers, you don't
understand how logic works.
That is must have the actual mind-of-god
for programming seems too much. A partial
halt decider confuses the Hell out of newbies.
A halt decider over a specific domain is
the middle ground.
But you are confused. Turing Machine have NO mind, they don't "know"
anything, they just perform a mechanical operation.
It seems your problem is you just don't understand what you are
talking about.
The "specific domain" for any general decider on Turing Machines is
ALL Turing Machines.
Anything less, and you are just lying about what you are deciding on.
Yes, partial deciders that are able to always decide over a limited
range have SOME use, but don't solve the initial problem.
Such machines exist for many classes of sub-domains.
All Turing machines only compute the mapping
from an input finite string to some value.
Right, but to CORRECTLY be a machine to compute a specified
function, the mapping they generate needs to match that function for
all values.
Thus, a Halt Decider, given a finite string that specifies a given
Turing Machine (and its input) needs to return the result of if that
machine will halt when it is run.
It must be the actual sequence of steps that
this finite string as an input actually specify.
Then none of your inputs meet this requirement, as none of you input
have STEPS in them, only instructions that will decide what steps to do.
I have gone over this with LLM systems and they
give me lots of push-back yet get it every time.
Yes, you have repeated this nonsense many times, but are unable to
explain how the fact that your definitions and you examples don't
match show you know anything.
I have made my words so clear that the get it
in 10 pages rather than the 50 pages that it
used to take them.
No, you are just showing you don't know what you words mean.
If its answer is ever wrong, it isn't a halt decider.
Terms-of-the-art should never violate the base
meaning of the same term. This really hurts
effective communication.
Then you don't understand the field of Semantics. Normally terms-of-
art are a REFINEMENT of the wider common definition, so tend not to
"violate" it.
We could have a term-of-the-art
"died five minutes ago"
mean that he is in excellent health and
passed all of his health tests.
That would be a bad term of art, but that isn't what terms-of-art do.
Your repeat use of bad examples just shows that you are ignorant of
what you are talking out.
Rule-out literally means to get a ruler and
draw a black line through some words indicating
that they are now excluded.
That mental health uses this term backwards of
the rest of the world is itself quite nuts.
A rule-out in mental health means that these
issues are still being considered.
So, are you that familiar with mental-health terminology? A guess that
would be natural for someone who may have a history of contact with them.
And, I think you don't understand the meaning of the term there. "A
Rule-Out" is a process that eliminates some possibilities by a process
that determines that the can't exist.
The final condition(s) left are not called "rule-out" but are the
conditions left after the rule-out process.
Again, showing a lack of understanding of the terminology that you
have heard and guessed its meaning.
I just verified this again. That is the way
that it works everywhere besides mental health. https://www.reddit.com/r/AuDHDWomen/comments/18yvozx/ what_does_rule_out_diagnoses_mean/
If you think things can be wrong at time, but still right, you are
admitting that you accept that you logic is just inconsistant.
On 12/13/2025 2:21 PM, Richard Damon wrote:
On 12/13/25 2:43 PM, olcott wrote:
Here is an insight that LLM Kimi suggested entirely
on the basis of the text of my first principles.
The Universal TM's Illusion: The UTM appears
to "simulate another machine," but it's really just
interpreting a string as a lookup table for state
transitions. The simulation is pure string rewriting.
Yes, Simulating a Turing Machine is just a series of string rewriting,
as that is what a Turing Machine does.
It is just a stateful string re-writer.
Two agreements in the same day, that is great.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,090 |
| Nodes: | 10 (0 / 10) |
| Uptime: | 156:55:48 |
| Calls: | 13,922 |
| Calls today: | 3 |
| Files: | 187,021 |
| D/L today: |
4,131 files (1,056M bytes) |
| Messages: | 2,457,227 |