Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
On 12/19/2025 7:27 PM, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
It is only clear on points 1-6 on pages 7-9.
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
There is a halt decider for the HP counter-example
input. The definition of halt decider required by the
halting problem contradicts the definition of computation.
You can see that I am correct when you pay attention.
to pages 7-9.
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
Pages 7-8 prove that the halting problem
itself is incorrect. There are no halt
deciders that are able to derive the halt
status from non-inputs.
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
Your problem is you don't understand about Rules and Requirements,--
because, you don't understand what TRUTH is because you are just a pathological liar.
You think it is valid to call things as they are not and assume that
makes it so.
That just shows you don't understand how logic works, and thus what
truth is,
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
A halt decider is nothing more than a specialized
decider. It can only make its decision on the basis
of finite string transformation rules.
Your problem is you don't understand about Rules and Requirements,
because, you don't understand what TRUTH is because you are just a
pathological liar.
You think it is valid to call things as they are not and assume that
makes it so.
That just shows you don't understand how logic works, and thus what
truth is,
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from the finite string.
But, if the thing it needs to compute isn't computable, it can't exist.
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from the finite
string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
But, if the thing it needs to compute isn't computable, it can't exist.
When it is computable from the finite string yet
this result disagrees with the requirement then
the requirement is wrong.
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from the
finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep the terms straight because you mind is to crooked.
The behavior of the finite string that represents this Program P, built
on your defined program H is computable, as shown by the fact that
UTM(P) produces the required result of the behavior of running this
program P.
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from the
finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep the terms
straight because you mind is to crooked.
The behavior of the finite string that represents this Program P,
built on your defined program H is computable, as shown by the fact
that UTM(P) produces the required result of the behavior of running
this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from the
finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep the
terms straight because you mind is to crooked.
The behavior of the finite string that represents this Program P,
built on your defined program H is computable, as shown by the fact
that UTM(P) produces the required result of the behavior of running
this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from the
finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep the
terms straight because you mind is to crooked.
The behavior of the finite string that represents this Program P,
built on your defined program H is computable, as shown by the fact
that UTM(P) produces the required result of the behavior of running
this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from the >>>>>>> finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep the
terms straight because you mind is to crooked.
The behavior of the finite string that represents this Program P,
built on your defined program H is computable, as shown by the fact >>>>> that UTM(P) produces the required result of the behavior of running >>>>> this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string transformation, that
can't be the definition of what determines the answer.
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from the >>>>>>>> finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep the
terms straight because you mind is to crooked.
The behavior of the finite string that represents this Program P, >>>>>> built on your defined program H is computable, as shown by the
fact that UTM(P) produces the required result of the behavior of
running this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string transformation, that
can't be the definition of what determines the answer.
Try and figure out how HHH can apply better finite string
transformation rules to *ITS ACTUAL INPUT* than DD simulated
by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
On 12/20/25 4:36 PM, olcott wrote:
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all. >>>>>>>>>>>>>
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from the >>>>>>>>> finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep the >>>>>>> terms straight because you mind is to crooked.
The behavior of the finite string that represents this Program P, >>>>>>> built on your defined program H is computable, as shown by the
fact that UTM(P) produces the required result of the behavior of >>>>>>> running this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string transformation, that
can't be the definition of what determines the answer.
Try and figure out how HHH can apply better finite string
transformation rules to *ITS ACTUAL INPUT* than DD simulated
by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
Why does it need to?
On 12/20/2025 4:02 PM, Richard Damon wrote:
On 12/20/25 4:36 PM, olcott wrote:
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject} >>>>>>>>>>>>>>>
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all. >>>>>>>>>>>>>>
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from >>>>>>>>>> the finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep the >>>>>>>> terms straight because you mind is to crooked.
The behavior of the finite string that represents this Program >>>>>>>> P, built on your defined program H is computable, as shown by >>>>>>>> the fact that UTM(P) produces the required result of the
behavior of running this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string transformation, that
can't be the definition of what determines the answer.
Try and figure out how HHH can apply better finite string
transformation rules to *ITS ACTUAL INPUT* than DD simulated
by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
Why does it need to?
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
Both HHH(DD) and HHH1(DD) do this correctly.
On 12/20/25 5:05 PM, olcott wrote:
On 12/20/2025 4:02 PM, Richard Damon wrote:
On 12/20/25 4:36 PM, olcott wrote:
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject} >>>>>>>>>>>>>>>>
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all. >>>>>>>>>>>>>>>
The above defines the generic notion of decider.
There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from >>>>>>>>>>> the finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep >>>>>>>>> the terms straight because you mind is to crooked.
The behavior of the finite string that represents this Program >>>>>>>>> P, built on your defined program H is computable, as shown by >>>>>>>>> the fact that UTM(P) produces the required result of the
behavior of running this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string transformation, that >>>>> can't be the definition of what determines the answer.
Try and figure out how HHH can apply better finite string
transformation rules to *ITS ACTUAL INPUT* than DD simulated
by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
Why does it need to?
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
Both HHH(DD) and HHH1(DD) do this correctly.
Sure they are. They just need to use their finite string transformation
to get to the required answer.
After all, an XXX Decider needs to compute the XXX function of their input.
You are just showing you don't understand the concept of requirements.--
Since you never worry about meeting requirements, that seems just normal
for you. Your problem is you don't think YOU are "accountable" to the
rules, which is why you thought it was ok for you to have child porn.
On 12/20/2025 4:37 PM, Richard Damon wrote:
On 12/20/25 5:05 PM, olcott wrote:
On 12/20/2025 4:02 PM, Richard Damon wrote:
On 12/20/25 4:36 PM, olcott wrote:
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite >>>>>>>>>>>>>>>>> string transformation rules into {Accept, Reject} >>>>>>>>>>>>>>>>>
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all. >>>>>>>>>>>>>>>>
The above defines the generic notion of decider. >>>>>>>>>>>>>>> There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from >>>>>>>>>>>> the finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep >>>>>>>>>> the terms straight because you mind is to crooked.
The behavior of the finite string that represents this Program >>>>>>>>>> P, built on your defined program H is computable, as shown by >>>>>>>>>> the fact that UTM(P) produces the required result of the
behavior of running this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string transformation,
that can't be the definition of what determines the answer.
Try and figure out how HHH can apply better finite string
transformation rules to *ITS ACTUAL INPUT* than DD simulated
by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
Why does it need to?
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
Both HHH(DD) and HHH1(DD) do this correctly.
Sure they are. They just need to use their finite string
transformation to get to the required answer.
After all, an XXX Decider needs to compute the XXX function of their
input.
Only to the extent that there exists some finite
string transformation rules from its input that
derive the required result otherwise it turns out
that the requirements themselves are incorrect.
There are no correct finite string transformation
rules that HHH can possibly apply to its actual
input that derive the behavior of DD simulated by HHH1.
This ultimately means that the requirement itself
is incorrect and DD simulated by HHH overrules
the requirement.
You are just showing you don't understand the concept of requirements.
Since you never worry about meeting requirements, that seems just
normal for you. Your problem is you don't think YOU are "accountable"
to the rules, which is why you thought it was ok for you to have child
porn.
On 12/20/25 5:55 PM, olcott wrote:
On 12/20/2025 4:37 PM, Richard Damon wrote:
On 12/20/25 5:05 PM, olcott wrote:
On 12/20/2025 4:02 PM, Richard Damon wrote:
On 12/20/25 4:36 PM, olcott wrote:
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite >>>>>>>>>>>>>>>>>> string transformation rules into {Accept, Reject} >>>>>>>>>>>>>>>>>>
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all. >>>>>>>>>>>>>>>>>
The above defines the generic notion of decider. >>>>>>>>>>>>>>>> There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result from >>>>>>>>>>>>> the finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep >>>>>>>>>>> the terms straight because you mind is to crooked.
The behavior of the finite string that represents this
Program P, built on your defined program H is computable, as >>>>>>>>>>> shown by the fact that UTM(P) produces the required result of >>>>>>>>>>> the behavior of running this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string transformation,
that can't be the definition of what determines the answer.
Try and figure out how HHH can apply better finite string
transformation rules to *ITS ACTUAL INPUT* than DD simulated
by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
Why does it need to?
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
Both HHH(DD) and HHH1(DD) do this correctly.
Sure they are. They just need to use their finite string
transformation to get to the required answer.
After all, an XXX Decider needs to compute the XXX function of their
input.
Only to the extent that there exists some finite
string transformation rules from its input that
derive the required result otherwise it turns out
that the requirements themselves are incorrect.
Nope, to be an XXX Decider, you need to compute the XXX function.
On 12/20/2025 5:08 PM, Richard Damon wrote:
On 12/20/25 5:55 PM, olcott wrote:
On 12/20/2025 4:37 PM, Richard Damon wrote:
On 12/20/25 5:05 PM, olcott wrote:
On 12/20/2025 4:02 PM, Richard Damon wrote:
On 12/20/25 4:36 PM, olcott wrote:
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite >>>>>>>>>>>>>>>>>>> string transformation rules into {Accept, Reject} >>>>>>>>>>>>>>>>>>>As there are no halt deciders they don't work at all. >>>>>>>>>>>>>>>>>>
https://philpapers.org/archive/OLCDTF.pdf >>>>>>>>>>>>>>>>>>
The above defines the generic notion of decider. >>>>>>>>>>>>>>>>> There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result >>>>>>>>>>>>>> from the finite string.
Exactly.
Deciders: Transform finite strings by finite string
transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't keep >>>>>>>>>>>> the terms straight because you mind is to crooked.
The behavior of the finite string that represents this >>>>>>>>>>>> Program P, built on your defined program H is computable, as >>>>>>>>>>>> shown by the fact that UTM(P) produces the required result >>>>>>>>>>>> of the behavior of running this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string transformation, >>>>>>>> that can't be the definition of what determines the answer.
Try and figure out how HHH can apply better finite string
transformation rules to *ITS ACTUAL INPUT* than DD simulated
by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
Why does it need to?
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
Both HHH(DD) and HHH1(DD) do this correctly.
Sure they are. They just need to use their finite string
transformation to get to the required answer.
After all, an XXX Decider needs to compute the XXX function of their
input.
Only to the extent that there exists some finite
string transformation rules from its input that
derive the required result otherwise it turns out
that the requirements themselves are incorrect.
Nope, to be an XXX Decider, you need to compute the XXX function.
*Counter-factual on this basis*
(It did take me 22 years to derive that basis)
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
On 12/20/25 6:26 PM, olcott wrote:
On 12/20/2025 5:08 PM, Richard Damon wrote:
On 12/20/25 5:55 PM, olcott wrote:
On 12/20/2025 4:37 PM, Richard Damon wrote:
On 12/20/25 5:05 PM, olcott wrote:
On 12/20/2025 4:02 PM, Richard Damon wrote:
On 12/20/25 4:36 PM, olcott wrote:
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote:
On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite >>>>>>>>>>>>>>>>>>>> string transformation rules into {Accept, Reject} >>>>>>>>>>>>>>>>>>>>As there are no halt deciders they don't work at all. >>>>>>>>>>>>>>>>>>>
https://philpapers.org/archive/OLCDTF.pdf >>>>>>>>>>>>>>>>>>>
The above defines the generic notion of decider. >>>>>>>>>>>>>>>>>> There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what
generic deciders can do then this definition
is incorrect.
But it isn't. A Halt Decider needs to compute a result >>>>>>>>>>>>>>> from the finite string.
Exactly.
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>> transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't >>>>>>>>>>>>> keep the terms straight because you mind is to crooked. >>>>>>>>>>>>>
The behavior of the finite string that represents this >>>>>>>>>>>>> Program P, built on your defined program H is computable, >>>>>>>>>>>>> as shown by the fact that UTM(P) produces the required >>>>>>>>>>>>> result of the behavior of running this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string transformation, >>>>>>>>> that can't be the definition of what determines the answer.
Try and figure out how HHH can apply better finite string
transformation rules to *ITS ACTUAL INPUT* than DD simulated
by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
Why does it need to?
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
Both HHH(DD) and HHH1(DD) do this correctly.
Sure they are. They just need to use their finite string
transformation to get to the required answer.
After all, an XXX Decider needs to compute the XXX function of
their input.
Only to the extent that there exists some finite
string transformation rules from its input that
derive the required result otherwise it turns out
that the requirements themselves are incorrect.
Nope, to be an XXX Decider, you need to compute the XXX function.
*Counter-factual on this basis*
(It did take me 22 years to derive that basis)
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
WRONG, and prove your stupidity.
Remember you definition of a "Computable Function"?
If the Turing Machine doesn't compute the specified function, it failed
to do its duty.
All deciders with a specified function to compute are responsible to--
match that function.
Deciders without a specified function are basically worthless, as there answers are meaningless. The only question they answer is what does this program generate for this input.
On 12/20/2025 5:36 PM, Richard Damon wrote:
On 12/20/25 6:26 PM, olcott wrote:
On 12/20/2025 5:08 PM, Richard Damon wrote:
On 12/20/25 5:55 PM, olcott wrote:
On 12/20/2025 4:37 PM, Richard Damon wrote:
On 12/20/25 5:05 PM, olcott wrote:
On 12/20/2025 4:02 PM, Richard Damon wrote:
On 12/20/25 4:36 PM, olcott wrote:
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite >>>>>>>>>>>>>>>>>>>>> string transformation rules into {Accept, Reject} >>>>>>>>>>>>>>>>>>>>>As there are no halt deciders they don't work at all. >>>>>>>>>>>>>>>>>>>>
https://philpapers.org/archive/OLCDTF.pdf >>>>>>>>>>>>>>>>>>>>
The above defines the generic notion of decider. >>>>>>>>>>>>>>>>>>> There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what >>>>>>>>>>>>>>>>> generic deciders can do then this definition >>>>>>>>>>>>>>>>> is incorrect.
But it isn't. A Halt Decider needs to compute a result >>>>>>>>>>>>>>>> from the finite string.
Exactly.
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>> transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't >>>>>>>>>>>>>> keep the terms straight because you mind is to crooked. >>>>>>>>>>>>>>
The behavior of the finite string that represents this >>>>>>>>>>>>>> Program P, built on your defined program H is computable, >>>>>>>>>>>>>> as shown by the fact that UTM(P) produces the required >>>>>>>>>>>>>> result of the behavior of running this program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string transformation, >>>>>>>>>> that can't be the definition of what determines the answer. >>>>>>>>>>
Try and figure out how HHH can apply better finite string
transformation rules to *ITS ACTUAL INPUT* than DD simulated >>>>>>>>> by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
Why does it need to?
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
Both HHH(DD) and HHH1(DD) do this correctly.
Sure they are. They just need to use their finite string
transformation to get to the required answer.
After all, an XXX Decider needs to compute the XXX function of
their input.
Only to the extent that there exists some finite
string transformation rules from its input that
derive the required result otherwise it turns out
that the requirements themselves are incorrect.
Nope, to be an XXX Decider, you need to compute the XXX function.
*Counter-factual on this basis*
(It did take me 22 years to derive that basis)
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
WRONG, and prove your stupidity.
Remember you definition of a "Computable Function"?
If the Turing Machine doesn't compute the specified function, it
failed to do its duty.
Prior to my elaboration this was hidden in
a slightly incorrect basic frame-of-reference.
Yet with my elaboration it becomes clear that
when the function is not computable from the input
then it is the requirement that is wrong.
We when require sum(3,4) to produce the sum of 5 + 6
it is the requirement that is wrong.
With the halting problem the issue it is so
enormously more subtle that it took one guys
focus for 22 years.
It turns out that if undecidability is correct
then truth itself is broken. If I didn't know
that I would have given up after six months.
All deciders with a specified function to compute are responsible to
match that function.
Deciders without a specified function are basically worthless, as
there answers are meaningless. The only question they answer is what
does this program generate for this input.
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite
string transformation rules into {Accept, Reject}
https://philpapers.org/archive/OLCDTF.pdf
As there are no halt deciders they don't work at all.
Pages 7-8 prove that the halting problem
itself is incorrect.
On 12/20/25 6:56 PM, olcott wrote:
On 12/20/2025 5:36 PM, Richard Damon wrote:
On 12/20/25 6:26 PM, olcott wrote:
On 12/20/2025 5:08 PM, Richard Damon wrote:
On 12/20/25 5:55 PM, olcott wrote:
On 12/20/2025 4:37 PM, Richard Damon wrote:
On 12/20/25 5:05 PM, olcott wrote:
On 12/20/2025 4:02 PM, Richard Damon wrote:
On 12/20/25 4:36 PM, olcott wrote:
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote:
On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote:
On 20/12/2025 03:27, olcott wrote:
Deciders: Transform finite strings by finite >>>>>>>>>>>>>>>>>>>>>> string transformation rules into {Accept, Reject} >>>>>>>>>>>>>>>>>>>>>>As there are no halt deciders they don't work at all. >>>>>>>>>>>>>>>>>>>>>
https://philpapers.org/archive/OLCDTF.pdf >>>>>>>>>>>>>>>>>>>>>
The above defines the generic notion of decider. >>>>>>>>>>>>>>>>>>>> There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what >>>>>>>>>>>>>>>>>> generic deciders can do then this definition >>>>>>>>>>>>>>>>>> is incorrect.
But it isn't. A Halt Decider needs to compute a result >>>>>>>>>>>>>>>>> from the finite string.
Exactly.
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't >>>>>>>>>>>>>>> keep the terms straight because you mind is to crooked. >>>>>>>>>>>>>>>
The behavior of the finite string that represents this >>>>>>>>>>>>>>> Program P, built on your defined program H is computable, >>>>>>>>>>>>>>> as shown by the fact that UTM(P) produces the required >>>>>>>>>>>>>>> result of the behavior of running this program P. >>>>>>>>>>>>>>>
I was not as clear as possible:
Deciders: Transform finite string inputs by finite >>>>>>>>>>>>>> string transformation rules into {Accept, Reject}. >>>>>>>>>>>>>>
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string
transformation, that can't be the definition of what
determines the answer.
Try and figure out how HHH can apply better finite string
transformation rules to *ITS ACTUAL INPUT* than DD simulated >>>>>>>>>> by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
Why does it need to?
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
Both HHH(DD) and HHH1(DD) do this correctly.
Sure they are. They just need to use their finite string
transformation to get to the required answer.
After all, an XXX Decider needs to compute the XXX function of
their input.
Only to the extent that there exists some finite
string transformation rules from its input that
derive the required result otherwise it turns out
that the requirements themselves are incorrect.
Nope, to be an XXX Decider, you need to compute the XXX function.
*Counter-factual on this basis*
(It did take me 22 years to derive that basis)
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
WRONG, and prove your stupidity.
Remember you definition of a "Computable Function"?
If the Turing Machine doesn't compute the specified function, it
failed to do its duty.
Prior to my elaboration this was hidden in
a slightly incorrect basic frame-of-reference.
No it isn/t
Yet with my elaboration it becomes clear that
when the function is not computable from the input
then it is the requirement that is wrong.
No it isn't. That is just your error.
To be a ligitimate problem, the mapping needs to be a total mapping,
where all input values generate a specific output value.
The mapping being non-computable doesn't make it invalid, it just make
it so no such machine can exist.
We when require sum(3,4) to produce the sum of 5 + 6
it is the requirement that is wrong.
But that is you just being stupid.
H(P) asks what P does. A Fully rational question.
With the halting problem the issue it is so
enormously more subtle that it took one guys
focus for 22 years.
No, you wasted 22 years because you made yourself intentionally ignornat.
It turns out that if undecidability is correct
then truth itself is broken. If I didn't know
that I would have given up after six months.
Nope, the only thing that breaks is your concept that truth must be knowable, which never was a thing,
Your problem is you don't actually understand what Truth is, confusing
it with things that are knowable.
All deciders with a specified function to compute are responsible to
match that function.
Deciders without a specified function are basically worthless, as
there answers are meaningless. The only question they answer is what
does this program generate for this input.
On 12/20/2025 6:42 PM, Richard Damon wrote:
On 12/20/25 6:56 PM, olcott wrote:
On 12/20/2025 5:36 PM, Richard Damon wrote:
On 12/20/25 6:26 PM, olcott wrote:
On 12/20/2025 5:08 PM, Richard Damon wrote:
On 12/20/25 5:55 PM, olcott wrote:
On 12/20/2025 4:37 PM, Richard Damon wrote:
On 12/20/25 5:05 PM, olcott wrote:
On 12/20/2025 4:02 PM, Richard Damon wrote:
On 12/20/25 4:36 PM, olcott wrote:
On 12/20/2025 3:17 PM, Richard Damon wrote:
On 12/20/25 3:56 PM, olcott wrote:
On 12/20/2025 2:41 PM, Richard Damon wrote:
On 12/20/25 3:19 PM, olcott wrote:
On 12/20/2025 1:51 PM, Richard Damon wrote:
On 12/20/25 2:22 PM, olcott wrote:
On 12/20/2025 12:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 12/20/25 9:54 AM, olcott wrote:
On 12/20/2025 8:41 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 12/20/25 8:49 AM, olcott wrote:
On 12/20/2025 4:07 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 20/12/2025 03:27, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> Deciders: Transform finite strings by finite >>>>>>>>>>>>>>>>>>>>>>> string transformation rules into {Accept, Reject} >>>>>>>>>>>>>>>>>>>>>>>
https://philpapers.org/archive/OLCDTF.pdf >>>>>>>>>>>>>>>>>>>>>>As there are no halt deciders they don't work at all. >>>>>>>>>>>>>>>>>>>>>>
The above defines the generic notion of decider. >>>>>>>>>>>>>>>>>>>>> There are deciders.
But not Halt Deciders.
When a halt decider is defined to exceed what >>>>>>>>>>>>>>>>>>> generic deciders can do then this definition >>>>>>>>>>>>>>>>>>> is incorrect.
But it isn't. A Halt Decider needs to compute a result >>>>>>>>>>>>>>>>>> from the finite string.
Exactly.
Deciders: Transform finite strings by finite string >>>>>>>>>>>>>>>>> transformation rules into {Accept, Reject}.
So, you are just admitting you are stupid, as you can't >>>>>>>>>>>>>>>> keep the terms straight because you mind is to crooked. >>>>>>>>>>>>>>>>
The behavior of the finite string that represents this >>>>>>>>>>>>>>>> Program P, built on your defined program H is >>>>>>>>>>>>>>>> computable, as shown by the fact that UTM(P) produces >>>>>>>>>>>>>>>> the required result of the behavior of running this >>>>>>>>>>>>>>>> program P.
I was not as clear as possible:
Deciders: Transform finite string inputs by finite >>>>>>>>>>>>>>> string transformation rules into {Accept, Reject}. >>>>>>>>>>>>>>>
There are no finite string transformation rules
that H can apply to its input P that derive the
behavior of UTM(P).
That isn't a valid statement,
Prove that it isn't a valid statement by showing
the finite string transformations that HHH can
apply to DD to derive the same behavior as DD
simulated by HHH1.
Since HHH only does one specific finite string
transformation, that can't be the definition of what
determines the answer.
Try and figure out how HHH can apply better finite string >>>>>>>>>>> transformation rules to *ITS ACTUAL INPUT* than DD simulated >>>>>>>>>>> by HHH. DO this so that it derives the same behavior as
DD simulated by HHH1.
Why does it need to?
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
Both HHH(DD) and HHH1(DD) do this correctly.
Sure they are. They just need to use their finite string
transformation to get to the required answer.
After all, an XXX Decider needs to compute the XXX function of >>>>>>>> their input.
Only to the extent that there exists some finite
string transformation rules from its input that
derive the required result otherwise it turns out
that the requirements themselves are incorrect.
Nope, to be an XXX Decider, you need to compute the XXX function.
*Counter-factual on this basis*
(It did take me 22 years to derive that basis)
Deciders: Transform finite string inputs by finite
string transformation rules into {Accept, Reject}.
They are not accountable for anything else.
WRONG, and prove your stupidity.
Remember you definition of a "Computable Function"?
If the Turing Machine doesn't compute the specified function, it
failed to do its duty.
Prior to my elaboration this was hidden in
a slightly incorrect basic frame-of-reference.
No it isn/t
Yet with my elaboration it becomes clear that
when the function is not computable from the input
then it is the requirement that is wrong.
No it isn't. That is just your error.
To be a ligitimate problem, the mapping needs to be a total mapping,
where all input values generate a specific output value.
The mapping being non-computable doesn't make it invalid, it just make
it so no such machine can exist.
We when require sum(3,4) to produce the sum of 5 + 6
it is the requirement that is wrong.
But that is you just being stupid.
H(P) asks what P does. A Fully rational question.
Can Carol correctly answer “no” to this (yes/no) question?
E C R Hehner. Objective and Subjective Specifications
WST Workshop on Termination, Oxford. 2018 July 18.
See https://www.cs.toronto.edu/~hehner/OSS.pdf
With the halting problem the issue it is so
enormously more subtle that it took one guys
focus for 22 years.
No, you wasted 22 years because you made yourself intentionally ignornat.
Three different LLMs have verified the my reasoning
is correctly semantically entailed from first principles
derived from standard definitions.
This is the only first principle needed and it is
derived from standard definitions:
Deciders: Transform finite string inputs by finite string
transformation rules into {Accept, Reject} values.
It is the correct semantic entailment that you are having
difficulty with.
It turns out that if undecidability is correct
then truth itself is broken. If I didn't know
that I would have given up after six months.
Nope, the only thing that breaks is your concept that truth must be
knowable, which never was a thing,
When-so-ever we start with correct first-principles
and only apply correct semantic entailment to those
first principles then correct conclusions are necessarily
derived, even if everyone disagrees.
Your problem is you don't actually understand what Truth is, confusing
it with things that are knowable.
I have fully addressed that now.
"true on the basis of meaning expressed in language"
for the entire body of general knowledge.
All deciders with a specified function to compute are responsible to
match that function.
Deciders without a specified function are basically worthless, as
there answers are meaningless. The only question they answer is what
does this program generate for this input.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,090 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 59:52:21 |
| Calls: | 13,948 |
| Calls today: | 1 |
| Files: | 187,035 |
| D/L today: |
2,695 files (773M bytes) |
| Messages: | 2,461,298 |