| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 26 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 48:47:44 |
| Calls: | 632 |
| Files: | 1,187 |
| D/L today: |
3 files (4,227K bytes) |
| Messages: | 177,138 |
On 10/7/2025 3:35 AM, Mikko wrote:
On 2025-10-07 00:28:40 +0000, olcott said:
On 10/6/2025 4:32 AM, Mikko wrote:
On 2025-10-05 13:34:29 +0000, olcott said:
On 10/4/2025 7:44 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 6:06 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
The problem here is that there is no
actual input that does the above.
Yes there is. A finite string input presented to a halting decider >>>>>>>> can easily contain all these ingredients:
- a clone of that same decider;
- a coded reference to itself;
- a call to the decider, passing itself;
- additional logic to behave opposite.
And different behavior than the behavior
THAT THIS INPUT ACTUALLY SPECIFIES.
That's an outlandish assertion with no proof.
I have focused on pathological self-reference(Olcott 2004).
It is just like ALL YOU PEOPLE are saying that
the liar paradox: "This sentence is not true"
No, there is no sentence (or logical predicate) in the above
which is self-referentially asserting a truth/falsehood.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Both values that any H can say are contradicted
just like both truth values of this sentence are
contradicted: "this sentence is not true"
H can only say one truth value about P. That one is contradicted.
The other is not.
WTF can't you pay attention ???
WTF can't you pay attention ???
WTF can't you pay attention ???
Of ocurse I can, at least to the extent needed here.
Every element of an infinite set !!!
Every element of an infinite set !!!
Every element of an infinite set !!!
That's right, what I said is true about every H/P-pair, as you called
them above.
*Here is the halting problem as the Liar Paradox*
*published here back in 2004*
On 6/23/2004 9:34 PM, Olcott wrote:
function LoopIfYouSayItHalts (bool YouSayItHalts):
if YouSayItHalts () then
while true do {}
else
return false;
Does this program Halt?
(Your (YES or NO) answer is to be considered
translated to Boolean as the function's input
parameter)
Please ONLY PROVIDE CORRECT ANSWERS!
On 10/7/2025 3:44 AM, Mikko wrote:
On 2025-10-07 00:30:38 +0000, olcott said:
On 10/6/2025 4:41 AM, Mikko wrote:
On 2025-10-05 14:19:02 +0000, olcott said:
On 10/5/2025 4:21 AM, Mikko wrote:
On 2025-10-04 23:03:06 +0000, olcott said:
On 10/4/2025 5:59 PM, Mr Flibble wrote:
Olcott admits that the Halting Problem is undecidable with the following
words quoted verbatim:
DD is the caller of HHH(DD) that does the opposite of whatever HHH(DD)/Flibble
reports. This makes it logically impossible for HHH to correctly report
on the behavior of its caller no matter what HHH does.
So if HHH is asked the question does my caller halt?
It is logically impossible for HHH to provide a correct answer. >>>>>>>>
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
The problem here is that there is no
actual input that does the above.
If there is no way-a to give the specification of the behaviour of P >>>>>> to H then H is not a halt decider.
rf?Mrf- Turing machine description of M.
reo* an arbitrary number of moves where a
move is the execution of one TM instruction.
reR the traditional infinite loop at the accept state.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
(a) -n copies its input rf?-nrf-
(b) -n invokes embedded_H rf?-nrf- rf?-nrf-
(c) embedded_H simulates rf?-nrf- rf?-nrf-
(d) rf?-nrf- copies its input rf?-nrf-
(e) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(f) embedded_H simulates rf?-nrf- rf?-nrf-
(h) rf?-nrf- copies its input rf?-nrf-
(i) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(j) embedded_H simulates rf?-nrf- rf?-nrf- ...
*Is the only behavior that the actual input has*
When embedded_H transitions to -n.qn that is
the behavior of itself not the behavior of its input.
If the actual input does not specify the behaviour of P then it
is a wrong
By this same fucking reasoning the liar paradox is true.
"This sentence is not true"
(a) Is not true
(b) Says it is not true
(c) Therefore must be true
No, it is not. The sentence "This sentence is not true" cannot be
assigned any truth value in an interpretation where "this sentence"
is interpreted to refer to the sentence itself and "is not true"
is interpreted to mean 'is not true'. But a computation either halts
or does not halt. I can't do both and it can't avoid both. So the
question "Does P specify a computation that halts" is a well-posed
question that has a correct answer.
*Conventional notion of the halting problem proof*
void P()
{
if H(P) // returns 1 for halts 0 for loops
HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making each H(P) always incorrect.
Some of them said halts and were wrong
some of them said loops and were wrong
both halts and loops were wrong.
Making the question posed to H: Does P halt?
have the empty set as its solution set.
On 2025-10-07 14:21:38 +0000, olcott said:
On 10/7/2025 3:35 AM, Mikko wrote:
On 2025-10-07 00:28:40 +0000, olcott said:
On 10/6/2025 4:32 AM, Mikko wrote:
On 2025-10-05 13:34:29 +0000, olcott said:
On 10/4/2025 7:44 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 6:06 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
The problem here is that there is no
actual input that does the above.
Yes there is. A finite string input presented to a halting decider >>>>>>>>> can easily contain all these ingredients:
- a clone of that same decider;
- a coded reference to itself;
- a call to the decider, passing itself;
- additional logic to behave opposite.
And different behavior than the behavior
THAT THIS INPUT ACTUALLY SPECIFIES.
That's an outlandish assertion with no proof.
I have focused on pathological self-reference(Olcott 2004).
It is just like ALL YOU PEOPLE are saying that
the liar paradox: "This sentence is not true"
No, there is no sentence (or logical predicate) in the above
which is self-referentially asserting a truth/falsehood.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Both values that any H can say are contradicted
just like both truth values of this sentence are
contradicted: "this sentence is not true"
H can only say one truth value about P. That one is contradicted.
The other is not.
WTF can't you pay attention ???
WTF can't you pay attention ???
WTF can't you pay attention ???
Of ocurse I can, at least to the extent needed here.
Every element of an infinite set !!!
Every element of an infinite set !!!
Every element of an infinite set !!!
That's right, what I said is true about every H/P-pair, as you called
them above.
*Here is the halting problem as the Liar Paradox*
*published here back in 2004*
On 6/23/2004 9:34 PM, Olcott wrote:
function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;
Does this program Halt?
(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)
Please ONLY PROVIDE CORRECT ANSWERS!
The program calls the function YouSayItHalts, which is neither
shown nor described. The behaviour after the call depends on
what that function does. Therefore the given information is
insufficent to determine whether it halts.
On 2025-10-07 14:27:07 +0000, olcott said:
On 10/7/2025 3:44 AM, Mikko wrote:
On 2025-10-07 00:30:38 +0000, olcott said:
On 10/6/2025 4:41 AM, Mikko wrote:
On 2025-10-05 14:19:02 +0000, olcott said:
On 10/5/2025 4:21 AM, Mikko wrote:
On 2025-10-04 23:03:06 +0000, olcott said:
On 10/4/2025 5:59 PM, Mr Flibble wrote:
Olcott admits that the Halting Problem is undecidable with the >>>>>>>>> following
words quoted verbatim:
DD is the caller of HHH(DD) that does the opposite of whatever >>>>>>>>>> HHH(DD)/Flibble
reports. This makes it logically impossible for HHH to
correctly report
on the behavior of its caller no matter what HHH does.
So if HHH is asked the question does my caller halt?
It is logically impossible for HHH to provide a correct answer. >>>>>>>>>
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
The problem here is that there is no
actual input that does the above.
If there is no way-a to give the specification of the behaviour of P >>>>>>> to H then H is not a halt decider.
rf?Mrf- Turing machine description of M.
reo* an arbitrary number of moves where a
move is the execution of one TM instruction.
reR the traditional infinite loop at the accept state.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
(a) -n copies its input rf?-nrf-
(b) -n invokes embedded_H rf?-nrf- rf?-nrf-
(c) embedded_H simulates rf?-nrf- rf?-nrf-
(d) rf?-nrf- copies its input rf?-nrf-
(e) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(f) embedded_H simulates rf?-nrf- rf?-nrf-
(h) rf?-nrf- copies its input rf?-nrf-
(i) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(j) embedded_H simulates rf?-nrf- rf?-nrf- ...
*Is the only behavior that the actual input has*
When embedded_H transitions to -n.qn that is
the behavior of itself not the behavior of its input.
If the actual input does not specify the behaviour of P then it
is a wrong
By this same fucking reasoning the liar paradox is true.
"This sentence is not true"
(a) Is not true
(b) Says it is not true
(c) Therefore must be true
No, it is not. The sentence "This sentence is not true" cannot be
assigned any truth value in an interpretation where "this sentence"
is interpreted to refer to the sentence itself and "is not true"
is interpreted to mean 'is not true'. But a computation either halts
or does not halt. I can't do both and it can't avoid both. So the
question "Does P specify a computation that halts" is a well-posed
question that has a correct answer.
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making each H(P) always incorrect.
Some of them said halts and were wrong
some of them said loops and were wrong
both halts and loops were wrong.
Making the question posed to H: Does P halt?
have the empty set as its solution set.
Nice to see that you don't disagree.
On 10/7/2025 3:35 AM, Mikko wrote:
On 2025-10-07 00:28:40 +0000, olcott said:
On 10/6/2025 4:32 AM, Mikko wrote:
On 2025-10-05 13:34:29 +0000, olcott said:
On 10/4/2025 7:44 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 6:06 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
The problem here is that there is no
actual input that does the above.
Yes there is. A finite string input presented to a halting decider >>>>>>>> can easily contain all these ingredients:
- a clone of that same decider;
- a coded reference to itself;
- a call to the decider, passing itself;
- additional logic to behave opposite.
And different behavior than the behavior
THAT THIS INPUT ACTUALLY SPECIFIES.
That's an outlandish assertion with no proof.
I have focused on pathological self-reference(Olcott 2004).
It is just like ALL YOU PEOPLE are saying that
the liar paradox: "This sentence is not true"
No, there is no sentence (or logical predicate) in the above
which is self-referentially asserting a truth/falsehood.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Both values that any H can say are contradicted
just like both truth values of this sentence are
contradicted: "this sentence is not true"
H can only say one truth value about P. That one is contradicted.
The other is not.
WTF can't you pay attention ???
WTF can't you pay attention ???
WTF can't you pay attention ???
Of ocurse I can, at least to the extent needed here.
Every element of an infinite set !!!
Every element of an infinite set !!!
Every element of an infinite set !!!
That's right, what I said is true about every H/P-pair, as you called
them above.
*Here is the halting problem as the Liar Paradox*
*published here back in 2004*
On 6/23/2004 9:34 PM, Olcott wrote:
function LoopIfYouSayItHalts (bool YouSayItHalts):
if YouSayItHalts () then
while true do {}
else
return false;
On 10/8/2025 4:21 AM, Mikko wrote:
On 2025-10-07 14:27:07 +0000, olcott said:
On 10/7/2025 3:44 AM, Mikko wrote:
On 2025-10-07 00:30:38 +0000, olcott said:
On 10/6/2025 4:41 AM, Mikko wrote:
On 2025-10-05 14:19:02 +0000, olcott said:
On 10/5/2025 4:21 AM, Mikko wrote:
On 2025-10-04 23:03:06 +0000, olcott said:
On 10/4/2025 5:59 PM, Mr Flibble wrote:
Olcott admits that the Halting Problem is undecidable with the following
words quoted verbatim:
DD is the caller of HHH(DD) that does the opposite of whatever HHH(DD)/Flibble
reports. This makes it logically impossible for HHH to correctly report
on the behavior of its caller no matter what HHH does.
So if HHH is asked the question does my caller halt?
It is logically impossible for HHH to provide a correct answer. >>>>>>>>>>
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
The problem here is that there is no
actual input that does the above.
If there is no way-a to give the specification of the behaviour of P >>>>>>>> to H then H is not a halt decider.
rf?Mrf- Turing machine description of M.
reo* an arbitrary number of moves where a
move is the execution of one TM instruction.
reR the traditional infinite loop at the accept state.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
(a) -n copies its input rf?-nrf-
(b) -n invokes embedded_H rf?-nrf- rf?-nrf-
(c) embedded_H simulates rf?-nrf- rf?-nrf-
(d) rf?-nrf- copies its input rf?-nrf-
(e) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(f) embedded_H simulates rf?-nrf- rf?-nrf-
(h) rf?-nrf- copies its input rf?-nrf-
(i) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(j) embedded_H simulates rf?-nrf- rf?-nrf- ...
*Is the only behavior that the actual input has*
When embedded_H transitions to -n.qn that is
the behavior of itself not the behavior of its input.
If the actual input does not specify the behaviour of P then it
is a wrong
By this same fucking reasoning the liar paradox is true.
"This sentence is not true"
(a) Is not true
(b) Says it is not true
(c) Therefore must be true
No, it is not. The sentence "This sentence is not true" cannot be
assigned any truth value in an interpretation where "this sentence"
is interpreted to refer to the sentence itself and "is not true"
is interpreted to mean 'is not true'. But a computation either halts
or does not halt. I can't do both and it can't avoid both. So the
question "Does P specify a computation that halts" is a well-posed
question that has a correct answer.
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making each H(P) always incorrect.
Some of them said halts and were wrong
some of them said loops and were wrong
both halts and loops were wrong.
Making the question posed to H: Does P halt?
have the empty set as its solution set.
Nice to see that you don't disagree.
It is modeled after the Liar Paradox so it is really
just a ruse pretending to be a decision problem.
On 2025-10-07 14:21:38 +0000, olcott said:
On 10/7/2025 3:35 AM, Mikko wrote:
On 2025-10-07 00:28:40 +0000, olcott said:
On 10/6/2025 4:32 AM, Mikko wrote:
On 2025-10-05 13:34:29 +0000, olcott said:
On 10/4/2025 7:44 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 6:06 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
The problem here is that there is no
actual input that does the above.
Yes there is. A finite string input presented to a halting decider >>>>>>>>> can easily contain all these ingredients:
- a clone of that same decider;
- a coded reference to itself;
- a call to the decider, passing itself;
- additional logic to behave opposite.
And different behavior than the behavior
THAT THIS INPUT ACTUALLY SPECIFIES.
That's an outlandish assertion with no proof.
I have focused on pathological self-reference(Olcott 2004).
It is just like ALL YOU PEOPLE are saying that
the liar paradox: "This sentence is not true"
No, there is no sentence (or logical predicate) in the above
which is self-referentially asserting a truth/falsehood.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Both values that any H can say are contradicted
just like both truth values of this sentence are
contradicted: "this sentence is not true"
H can only say one truth value about P. That one is contradicted.
The other is not.
WTF can't you pay attention ???
WTF can't you pay attention ???
WTF can't you pay attention ???
Of ocurse I can, at least to the extent needed here.
Every element of an infinite set !!!
Every element of an infinite set !!!
Every element of an infinite set !!!
That's right, what I said is true about every H/P-pair, as you called
them above.
*Here is the halting problem as the Liar Paradox*
*published here back in 2004*
On 6/23/2004 9:34 PM, Olcott wrote:
function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;
Which programming language's semantics should be applied to the
above?
On 2025-10-09 03:44:33 +0000, olcott said:
On 10/8/2025 4:21 AM, Mikko wrote:
On 2025-10-07 14:27:07 +0000, olcott said:
On 10/7/2025 3:44 AM, Mikko wrote:
On 2025-10-07 00:30:38 +0000, olcott said:
On 10/6/2025 4:41 AM, Mikko wrote:
On 2025-10-05 14:19:02 +0000, olcott said:
On 10/5/2025 4:21 AM, Mikko wrote:
On 2025-10-04 23:03:06 +0000, olcott said:
On 10/4/2025 5:59 PM, Mr Flibble wrote:
Olcott admits that the Halting Problem is undecidable with >>>>>>>>>>> the following
words quoted verbatim:
DD is the caller of HHH(DD) that does the opposite of >>>>>>>>>>>> whatever HHH(DD)/Flibble
reports. This makes it logically impossible for HHH to >>>>>>>>>>>> correctly report
on the behavior of its caller no matter what HHH does. >>>>>>>>>>>>
So if HHH is asked the question does my caller halt?
It is logically impossible for HHH to provide a correct answer. >>>>>>>>>>>
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
The problem here is that there is no
actual input that does the above.
If there is no way-a to give the specification of the behaviour >>>>>>>>> of P
to H then H is not a halt decider.
rf?Mrf- Turing machine description of M.
reo* an arbitrary number of moves where a
move is the execution of one TM instruction.
reR the traditional infinite loop at the accept state.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
(a) -n copies its input rf?-nrf-
(b) -n invokes embedded_H rf?-nrf- rf?-nrf-
(c) embedded_H simulates rf?-nrf- rf?-nrf-
(d) rf?-nrf- copies its input rf?-nrf-
(e) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(f) embedded_H simulates rf?-nrf- rf?-nrf-
(h) rf?-nrf- copies its input rf?-nrf-
(i) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(j) embedded_H simulates rf?-nrf- rf?-nrf- ...
*Is the only behavior that the actual input has*
When embedded_H transitions to -n.qn that is
the behavior of itself not the behavior of its input.
If the actual input does not specify the behaviour of P then it
is a wrong
By this same fucking reasoning the liar paradox is true.
"This sentence is not true"
(a) Is not true
(b) Says it is not true
(c) Therefore must be true
No, it is not. The sentence "This sentence is not true" cannot be
assigned any truth value in an interpretation where "this sentence"
is interpreted to refer to the sentence itself and "is not true"
is interpreted to mean 'is not true'. But a computation either halts >>>>> or does not halt. I can't do both and it can't avoid both. So the
question "Does P specify a computation that halts" is a well-posed
question that has a correct answer.
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making each H(P) always incorrect.
Some of them said halts and were wrong
some of them said loops and were wrong
both halts and loops were wrong.
Making the question posed to H: Does P halt?
have the empty set as its solution set.
Nice to see that you don't disagree.
It is modeled after the Liar Paradox so it is really
just a ruse pretending to be a decision problem.
Nevertheless, P() can be encoded as a Turing machine with an empty
input tape and then given to a Turing mahine encoding of H, which
then fails to answer correctly whether P halts.
On 10/9/2025 4:28 AM, Mikko wrote:
On 2025-10-07 14:21:38 +0000, olcott said:
On 10/7/2025 3:35 AM, Mikko wrote:
On 2025-10-07 00:28:40 +0000, olcott said:
On 10/6/2025 4:32 AM, Mikko wrote:
On 2025-10-05 13:34:29 +0000, olcott said:
On 10/4/2025 7:44 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 6:06 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
The problem here is that there is no
actual input that does the above.
Yes there is. A finite string input presented to a halting decider >>>>>>>>>> can easily contain all these ingredients:
- a clone of that same decider;
- a coded reference to itself;
- a call to the decider, passing itself;
- additional logic to behave opposite.
And different behavior than the behavior
THAT THIS INPUT ACTUALLY SPECIFIES.
That's an outlandish assertion with no proof.
I have focused on pathological self-reference(Olcott 2004).
It is just like ALL YOU PEOPLE are saying that
the liar paradox: "This sentence is not true"
No, there is no sentence (or logical predicate) in the above
which is self-referentially asserting a truth/falsehood.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Both values that any H can say are contradicted
just like both truth values of this sentence are
contradicted: "this sentence is not true"
H can only say one truth value about P. That one is contradicted.
The other is not.
WTF can't you pay attention ???
WTF can't you pay attention ???
WTF can't you pay attention ???
Of ocurse I can, at least to the extent needed here.
Every element of an infinite set !!!
Every element of an infinite set !!!
Every element of an infinite set !!!
That's right, what I said is true about every H/P-pair, as you called
them above.
*Here is the halting problem as the Liar Paradox*
*published here back in 2004*
On 6/23/2004 9:34 PM, Olcott wrote:
function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;
Which programming language's semantics should be applied to the
above?
*I rewrote the whole hing in fully operational C*
#include <stdio.h>
#include <conio.h>
void LoopIfYouSayItHalts(bool YouSayItHalts)
{
if (YouSayItHalts)
while(true)
;
else
return;
}
void OutputProgram()
{
printf("\n\n\nvoid LoopIfYouSayItHalts "
"(bool YouSayItHalts)\n");
printf("{\n");
printf(" if (YouSayItHalts)\n");
printf(" while(true)\n");
printf(" ;\n");
printf(" else\n");
printf(" return;\n");
printf("}\n\n\n");
}
void Prompt()
{
char choice = 'x';
printf("Does this program Halt?\n");
printf("(Y or N) translated to Boolean argument"
" to LoopIfYouSayItHalts()\n");
printf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
while (choice != 'Y'&& choice != 'y' &&
choice != 'N' && choice != 'n')
{
choice = getch();
if (choice != 'Y'&& choice != 'y' &&
choice != 'N' && choice != 'n')
printf("Must be (Y or N)\n");
}
if (choice == 'Y' || choice == 'y')
{
printf("\nWrong Answer!\n"
"LoopIfYouSayItHalts(true) is stuck in a loop!\n\n");
LoopIfYouSayItHalts(true);
}
if (choice == 'N' || choice == 'n')
{
printf("\nWrong Answer!\n"
"LoopIfYouSayItHalts(false) halts now!\n\n");
LoopIfYouSayItHalts(false);
}
}
int main()
{
OutputProgram();
Prompt();
return 0;
}
On 10/9/2025 4:35 AM, Mikko wrote:
On 2025-10-09 03:44:33 +0000, olcott said:
On 10/8/2025 4:21 AM, Mikko wrote:
On 2025-10-07 14:27:07 +0000, olcott said:
On 10/7/2025 3:44 AM, Mikko wrote:
On 2025-10-07 00:30:38 +0000, olcott said:
On 10/6/2025 4:41 AM, Mikko wrote:
On 2025-10-05 14:19:02 +0000, olcott said:
On 10/5/2025 4:21 AM, Mikko wrote:
On 2025-10-04 23:03:06 +0000, olcott said:
On 10/4/2025 5:59 PM, Mr Flibble wrote:
Olcott admits that the Halting Problem is undecidable with the following
words quoted verbatim:
DD is the caller of HHH(DD) that does the opposite of whatever HHH(DD)/Flibble
reports. This makes it logically impossible for HHH to correctly report
on the behavior of its caller no matter what HHH does. >>>>>>>>>>>>>
So if HHH is asked the question does my caller halt? >>>>>>>>>>>>> It is logically impossible for HHH to provide a correct answer. >>>>>>>>>>>>
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
The problem here is that there is no
actual input that does the above.
If there is no way-a to give the specification of the behaviour of P >>>>>>>>>> to H then H is not a halt decider.
rf?Mrf- Turing machine description of M.
reo* an arbitrary number of moves where a
move is the execution of one TM instruction.
reR the traditional infinite loop at the accept state.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
(a) -n copies its input rf?-nrf-
(b) -n invokes embedded_H rf?-nrf- rf?-nrf-
(c) embedded_H simulates rf?-nrf- rf?-nrf-
(d) rf?-nrf- copies its input rf?-nrf-
(e) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(f) embedded_H simulates rf?-nrf- rf?-nrf-
(h) rf?-nrf- copies its input rf?-nrf-
(i) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(j) embedded_H simulates rf?-nrf- rf?-nrf- ...
*Is the only behavior that the actual input has*
When embedded_H transitions to -n.qn that is
the behavior of itself not the behavior of its input.
If the actual input does not specify the behaviour of P then it >>>>>>>> is a wrong
By this same fucking reasoning the liar paradox is true.
"This sentence is not true"
(a) Is not true
(b) Says it is not true
(c) Therefore must be true
No, it is not. The sentence "This sentence is not true" cannot be
assigned any truth value in an interpretation where "this sentence" >>>>>> is interpreted to refer to the sentence itself and "is not true"
is interpreted to mean 'is not true'. But a computation either halts >>>>>> or does not halt. I can't do both and it can't avoid both. So the
question "Does P specify a computation that halts" is a well-posed >>>>>> question that has a correct answer.
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making each H(P) always incorrect.
Some of them said halts and were wrong
some of them said loops and were wrong
both halts and loops were wrong.
Making the question posed to H: Does P halt?
have the empty set as its solution set.
Nice to see that you don't disagree.
It is modeled after the Liar Paradox so it is really
just a ruse pretending to be a decision problem.
Nevertheless, P() can be encoded as a Turing machine with an empty
input tape and then given to a Turing mahine encoding of H, which
then fails to answer correctly whether P halts.
My DD always has no arguments, thus the same
as an empty tape. When HHH(DD) determines the
halt status specified by the actual behavior
of its actual input by DD correctly simulated
by HHH, the correct halt status is reject.
On 2025-10-09 16:46:19 +0000, olcott said:
On 10/9/2025 4:28 AM, Mikko wrote:
On 2025-10-07 14:21:38 +0000, olcott said:
On 10/7/2025 3:35 AM, Mikko wrote:
On 2025-10-07 00:28:40 +0000, olcott said:
On 10/6/2025 4:32 AM, Mikko wrote:
On 2025-10-05 13:34:29 +0000, olcott said:
On 10/4/2025 7:44 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 6:06 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
The problem here is that there is no
actual input that does the above.
Yes there is. A finite string input presented to a halting >>>>>>>>>>> decider
can easily contain all these ingredients:
- a clone of that same decider;
- a coded reference to itself;
- a call to the decider, passing itself;
- additional logic to behave opposite.
And different behavior than the behavior
THAT THIS INPUT ACTUALLY SPECIFIES.
That's an outlandish assertion with no proof.
I have focused on pathological self-reference(Olcott 2004). >>>>>>>>>>
It is just like ALL YOU PEOPLE are saying that
the liar paradox: "This sentence is not true"
No, there is no sentence (or logical predicate) in the above >>>>>>>>> which is self-referentially asserting a truth/falsehood.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Both values that any H can say are contradicted
just like both truth values of this sentence are
contradicted: "this sentence is not true"
H can only say one truth value about P. That one is contradicted. >>>>>>> The other is not.
WTF can't you pay attention ???
WTF can't you pay attention ???
WTF can't you pay attention ???
Of ocurse I can, at least to the extent needed here.
Every element of an infinite set !!!
Every element of an infinite set !!!
Every element of an infinite set !!!
That's right, what I said is true about every H/P-pair, as you called >>>>> them above.
*Here is the halting problem as the Liar Paradox*
*published here back in 2004*
On 6/23/2004 9:34 PM, Olcott wrote:
function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;
Which programming language's semantics should be applied to the
above?
*I rewrote the whole hing in fully operational C*
#include <stdio.h>
#include <conio.h>
void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a-a if (YouSayItHalts)
-a-a-a-a while(true)
-a-a-a-a-a-a ;
-a-a else
-a-a-a-a return;
}
void OutputProgram()
{
-a-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a-a printf("{\n");
-a-a printf("-a if (YouSayItHalts)\n");
-a-a printf("-a-a-a while(true)\n");
-a-a printf("-a-a-a-a-a ;\n");
-a-a printf("-a else\n");
-a-a printf("-a-a-a return;\n");
-a-a printf("}\n\n\n");
}
void Prompt()
{
-a char choice = 'x';
-a printf("Does this program Halt?\n");
-a printf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-a printf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-a while (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a {
-a-a-a choice = getch();
-a-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a-a printf("Must be (Y or N)\n");
-a }
-a if (choice == 'Y' || choice == 'y')
-a {
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >> -a-a-a LoopIfYouSayItHalts(true);
-a }
-a if (choice == 'N' || choice == 'n')
-a {
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a-a LoopIfYouSayItHalts(false);
-a }
}
int main()
{
-a-a OutputProgram();
-a-a Prompt();
-a-a return 0;
}
The library conio.h is non-standard. Instead of getch it would be better
to use getchar.
It would be better to put the call to OutputProgram in the function
Prompt because the function Prompt is specifically made for this
program and would not make sense otherwise.
The function Prompt would be better if the variable choice would be
if the were immediately normlized to an integer or a lower case
letter.
Instead of "if (choice == 'N' || choice == 'n')" it would be better
to use "else".
The call to LoopIfYouSayItHalts could be moved out of the if-blocks
using "choice == 'Y' || choice == 'y'" as the argument value.
On 2025-10-09 16:59:54 +0000, olcott said:
On 10/9/2025 4:35 AM, Mikko wrote:
On 2025-10-09 03:44:33 +0000, olcott said:
On 10/8/2025 4:21 AM, Mikko wrote:
On 2025-10-07 14:27:07 +0000, olcott said:
On 10/7/2025 3:44 AM, Mikko wrote:
On 2025-10-07 00:30:38 +0000, olcott said:
On 10/6/2025 4:41 AM, Mikko wrote:
On 2025-10-05 14:19:02 +0000, olcott said:
On 10/5/2025 4:21 AM, Mikko wrote:
On 2025-10-04 23:03:06 +0000, olcott said:
On 10/4/2025 5:59 PM, Mr Flibble wrote:
Olcott admits that the Halting Problem is undecidable with >>>>>>>>>>>>> the following
words quoted verbatim:
DD is the caller of HHH(DD) that does the opposite of >>>>>>>>>>>>>> whatever HHH(DD)
reports. This makes it logically impossible for HHH to >>>>>>>>>>>>>> correctly report
on the behavior of its caller no matter what HHH does. >>>>>>>>>>>>>>
So if HHH is asked the question does my caller halt? >>>>>>>>>>>>>> It is logically impossible for HHH to provide a correct >>>>>>>>>>>>>> answer.
/Flibble
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
The problem here is that there is no
actual input that does the above.
If there is no way-a to give the specification of the
behaviour of P
to H then H is not a halt decider.
rf?Mrf- Turing machine description of M.
reo* an arbitrary number of moves where a
move is the execution of one TM instruction.
reR the traditional infinite loop at the accept state.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
(a) -n copies its input rf?-nrf-
(b) -n invokes embedded_H rf?-nrf- rf?-nrf-
(c) embedded_H simulates rf?-nrf- rf?-nrf-
(d) rf?-nrf- copies its input rf?-nrf-
(e) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(f) embedded_H simulates rf?-nrf- rf?-nrf-
(h) rf?-nrf- copies its input rf?-nrf-
(i) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(j) embedded_H simulates rf?-nrf- rf?-nrf- ...
*Is the only behavior that the actual input has*
When embedded_H transitions to -n.qn that is
the behavior of itself not the behavior of its input.
If the actual input does not specify the behaviour of P then it >>>>>>>>> is a wrong
By this same fucking reasoning the liar paradox is true.
"This sentence is not true"
(a) Is not true
(b) Says it is not true
(c) Therefore must be true
No, it is not. The sentence "This sentence is not true" cannot be >>>>>>> assigned any truth value in an interpretation where "this sentence" >>>>>>> is interpreted to refer to the sentence itself and "is not true" >>>>>>> is interpreted to mean 'is not true'. But a computation either halts >>>>>>> or does not halt. I can't do both and it can't avoid both. So the >>>>>>> question "Does P specify a computation that halts" is a well-posed >>>>>>> question that has a correct answer.
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making each H(P) always incorrect.
Some of them said halts and were wrong
some of them said loops and were wrong
both halts and loops were wrong.
Making the question posed to H: Does P halt?
have the empty set as its solution set.
Nice to see that you don't disagree.
It is modeled after the Liar Paradox so it is really
just a ruse pretending to be a decision problem.
Nevertheless, P() can be encoded as a Turing machine with an empty
input tape and then given to a Turing mahine encoding of H, which
then fails to answer correctly whether P halts.
My DD always has no arguments, thus the same
as an empty tape. When HHH(DD) determines the
halt status specified by the actual behavior
of its actual input by DD correctly simulated
by HHH, the correct halt status is reject.
No, the correct halt status is "halts" because DD halts.
On 10/10/2025 2:38 AM, Mikko wrote:
On 2025-10-09 16:46:19 +0000, olcott said:
On 10/9/2025 4:28 AM, Mikko wrote:
On 2025-10-07 14:21:38 +0000, olcott said:
On 10/7/2025 3:35 AM, Mikko wrote:
On 2025-10-07 00:28:40 +0000, olcott said:
On 10/6/2025 4:32 AM, Mikko wrote:
On 2025-10-05 13:34:29 +0000, olcott said:
On 10/4/2025 7:44 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 6:06 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
The problem here is that there is no
actual input that does the above.
Yes there is. A finite string input presented to a halting >>>>>>>>>>>> decider
can easily contain all these ingredients:
- a clone of that same decider;
- a coded reference to itself;
- a call to the decider, passing itself;
- additional logic to behave opposite.
And different behavior than the behavior
THAT THIS INPUT ACTUALLY SPECIFIES.
That's an outlandish assertion with no proof.
I have focused on pathological self-reference(Olcott 2004). >>>>>>>>>>>
It is just like ALL YOU PEOPLE are saying that
the liar paradox: "This sentence is not true"
No, there is no sentence (or logical predicate) in the above >>>>>>>>>> which is self-referentially asserting a truth/falsehood.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Both values that any H can say are contradicted
just like both truth values of this sentence are
contradicted: "this sentence is not true"
H can only say one truth value about P. That one is contradicted. >>>>>>>> The other is not.
WTF can't you pay attention ???
WTF can't you pay attention ???
WTF can't you pay attention ???
Of ocurse I can, at least to the extent needed here.
Every element of an infinite set !!!
Every element of an infinite set !!!
Every element of an infinite set !!!
That's right, what I said is true about every H/P-pair, as you called >>>>>> them above.
*Here is the halting problem as the Liar Paradox*
*published here back in 2004*
On 6/23/2004 9:34 PM, Olcott wrote:
function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;
Which programming language's semantics should be applied to the
above?
*I rewrote the whole hing in fully operational C*
#include <stdio.h>
#include <conio.h>
void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a-a if (YouSayItHalts)
-a-a-a-a while(true)
-a-a-a-a-a-a ;
-a-a else
-a-a-a-a return;
}
void OutputProgram()
{
-a-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a-a printf("{\n");
-a-a printf("-a if (YouSayItHalts)\n");
-a-a printf("-a-a-a while(true)\n");
-a-a printf("-a-a-a-a-a ;\n");
-a-a printf("-a else\n");
-a-a printf("-a-a-a return;\n");
-a-a printf("}\n\n\n");
}
void Prompt()
{
-a char choice = 'x';
-a printf("Does this program Halt?\n");
-a printf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-a printf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-a while (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a {
-a-a-a choice = getch();
-a-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a-a printf("Must be (Y or N)\n");
-a }
-a if (choice == 'Y' || choice == 'y')
-a {
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>> -a-a-a LoopIfYouSayItHalts(true);
-a }
-a if (choice == 'N' || choice == 'n')
-a {
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a-a LoopIfYouSayItHalts(false);
-a }
}
int main()
{
-a-a OutputProgram();
-a-a Prompt();
-a-a return 0;
}
The library conio.h is non-standard. Instead of getch it would be better
to use getchar.
I considered that and rejected it.
It makes the interface less clean.
One has to know to hit [enter] after
they type Y or N.
It would be better to put the call to OutputProgram in the function
Prompt because the function Prompt is specifically made for this
program and would not make sense otherwise.
I don't like to put too many things in one function.
That makes messy code that is harder to maintain.
The function Prompt would be better if the variable choice would be
if the were immediately normlized to an integer or a lower case
letter.
Instead of "if (choice == 'N' || choice == 'n')" it would be better
to use "else".
The call to LoopIfYouSayItHalts could be moved out of the if-blocks
using "choice == 'Y' || choice == 'y'" as the argument value.
You missed the whole point that I transformed
the HP counter example input into the Liar Paradox.
On 10/10/2025 2:40 AM, Mikko wrote:
On 2025-10-09 16:59:54 +0000, olcott said:
On 10/9/2025 4:35 AM, Mikko wrote:
On 2025-10-09 03:44:33 +0000, olcott said:
On 10/8/2025 4:21 AM, Mikko wrote:
On 2025-10-07 14:27:07 +0000, olcott said:
On 10/7/2025 3:44 AM, Mikko wrote:
On 2025-10-07 00:30:38 +0000, olcott said:
On 10/6/2025 4:41 AM, Mikko wrote:
On 2025-10-05 14:19:02 +0000, olcott said:
On 10/5/2025 4:21 AM, Mikko wrote:
On 2025-10-04 23:03:06 +0000, olcott said:
On 10/4/2025 5:59 PM, Mr Flibble wrote:
Olcott admits that the Halting Problem is undecidable with >>>>>>>>>>>>>> the following
words quoted verbatim:
DD is the caller of HHH(DD) that does the opposite of >>>>>>>>>>>>>>> whatever HHH(DD)
reports. This makes it logically impossible for HHH to >>>>>>>>>>>>>>> correctly report
on the behavior of its caller no matter what HHH does. >>>>>>>>>>>>>>>
So if HHH is asked the question does my caller halt? >>>>>>>>>>>>>>> It is logically impossible for HHH to provide a correct >>>>>>>>>>>>>>> answer.
/Flibble
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
The problem here is that there is no
actual input that does the above.
If there is no way-a to give the specification of the >>>>>>>>>>>> behaviour of P
to H then H is not a halt decider.
rf?Mrf- Turing machine description of M.
reo* an arbitrary number of moves where a
move is the execution of one TM instruction.
reR the traditional infinite loop at the accept state.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
(a) -n copies its input rf?-nrf-
(b) -n invokes embedded_H rf?-nrf- rf?-nrf-
(c) embedded_H simulates rf?-nrf- rf?-nrf-
(d) rf?-nrf- copies its input rf?-nrf-
(e) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(f) embedded_H simulates rf?-nrf- rf?-nrf-
(h) rf?-nrf- copies its input rf?-nrf-
(i) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(j) embedded_H simulates rf?-nrf- rf?-nrf- ...
*Is the only behavior that the actual input has*
When embedded_H transitions to -n.qn that is
the behavior of itself not the behavior of its input.
If the actual input does not specify the behaviour of P then it >>>>>>>>>> is a wrong
By this same fucking reasoning the liar paradox is true.
"This sentence is not true"
(a) Is not true
(b) Says it is not true
(c) Therefore must be true
No, it is not. The sentence "This sentence is not true" cannot be >>>>>>>> assigned any truth value in an interpretation where "this sentence" >>>>>>>> is interpreted to refer to the sentence itself and "is not true" >>>>>>>> is interpreted to mean 'is not true'. But a computation either >>>>>>>> halts
or does not halt. I can't do both and it can't avoid both. So the >>>>>>>> question "Does P specify a computation that halts" is a well-posed >>>>>>>> question that has a correct answer.
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making each H(P) always incorrect.
Some of them said halts and were wrong
some of them said loops and were wrong
both halts and loops were wrong.
Making the question posed to H: Does P halt?
have the empty set as its solution set.
Nice to see that you don't disagree.
It is modeled after the Liar Paradox so it is really
just a ruse pretending to be a decision problem.
Nevertheless, P() can be encoded as a Turing machine with an empty
input tape and then given to a Turing mahine encoding of H, which
then fails to answer correctly whether P halts.
My DD always has no arguments, thus the same
as an empty tape. When HHH(DD) determines the
halt status specified by the actual behavior
of its actual input by DD correctly simulated
by HHH, the correct halt status is reject.
No, the correct halt status is "halts" because DD halts.
Its like people here are morons.
The executing process that is the caller
of HHH(DD) IS NOT AN INPUT
On 10/10/2025 2:38 AM, Mikko wrote:
On 2025-10-09 16:46:19 +0000, olcott said:
On 10/9/2025 4:28 AM, Mikko wrote:
On 2025-10-07 14:21:38 +0000, olcott said:
On 10/7/2025 3:35 AM, Mikko wrote:
On 2025-10-07 00:28:40 +0000, olcott said:
On 10/6/2025 4:32 AM, Mikko wrote:
On 2025-10-05 13:34:29 +0000, olcott said:
On 10/4/2025 7:44 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
On 10/4/2025 6:06 PM, Kaz Kylheku wrote:
On 2025-10-04, olcott <polcott333@gmail.com> wrote:
The problem here is that there is no
actual input that does the above.
Yes there is. A finite string input presented to a halting decider >>>>>>>>>>>> can easily contain all these ingredients:
- a clone of that same decider;
- a coded reference to itself;
- a call to the decider, passing itself;
- additional logic to behave opposite.
And different behavior than the behavior
THAT THIS INPUT ACTUALLY SPECIFIES.
That's an outlandish assertion with no proof.
I have focused on pathological self-reference(Olcott 2004). >>>>>>>>>>>
It is just like ALL YOU PEOPLE are saying that
the liar paradox: "This sentence is not true"
No, there is no sentence (or logical predicate) in the above >>>>>>>>>> which is self-referentially asserting a truth/falsehood.
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
Both values that any H can say are contradicted
just like both truth values of this sentence are
contradicted: "this sentence is not true"
H can only say one truth value about P. That one is contradicted. >>>>>>>> The other is not.
WTF can't you pay attention ???
WTF can't you pay attention ???
WTF can't you pay attention ???
Of ocurse I can, at least to the extent needed here.
Every element of an infinite set !!!
Every element of an infinite set !!!
Every element of an infinite set !!!
That's right, what I said is true about every H/P-pair, as you called >>>>>> them above.
*Here is the halting problem as the Liar Paradox*
*published here back in 2004*
On 6/23/2004 9:34 PM, Olcott wrote:
function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;
Which programming language's semantics should be applied to the
above?
*I rewrote the whole hing in fully operational C*
#include <stdio.h>
#include <conio.h>
void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a-a if (YouSayItHalts)
-a-a-a-a while(true)
-a-a-a-a-a-a ;
-a-a else
-a-a-a-a return;
}
void OutputProgram()
{
-a-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a-a printf("{\n");
-a-a printf("-a if (YouSayItHalts)\n");
-a-a printf("-a-a-a while(true)\n");
-a-a printf("-a-a-a-a-a ;\n");
-a-a printf("-a else\n");
-a-a printf("-a-a-a return;\n");
-a-a printf("}\n\n\n");
}
void Prompt()
{
-a char choice = 'x';
-a printf("Does this program Halt?\n");
-a printf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-a printf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-a while (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a {
-a-a-a choice = getch();
-a-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a-a printf("Must be (Y or N)\n");
-a }
-a if (choice == 'Y' || choice == 'y')
-a {
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>> -a-a-a LoopIfYouSayItHalts(true);
-a }
-a if (choice == 'N' || choice == 'n')
-a {
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a-a LoopIfYouSayItHalts(false);
-a }
}
int main()
{
-a-a OutputProgram();
-a-a Prompt();
-a-a return 0;
}
The library conio.h is non-standard. Instead of getch it would be better
to use getchar.
I considered that and rejected it.
It makes the interface less clean.
One has to know to hit [enter] after
they type Y or N.
It would be better to put the call to OutputProgram in the function
Prompt because the function Prompt is specifically made for this
program and would not make sense otherwise.
I don't like to put too many things in one function.
That makes messy code that is harder to maintain.
The function Prompt would be better if the variable choice would be
if the were immediately normlized to an integer or a lower case
letter.
Instead of "if (choice == 'N' || choice == 'n')" it would be better
to use "else".
The call to LoopIfYouSayItHalts could be moved out of the if-blocks
using "choice == 'Y' || choice == 'y'" as the argument value.
You missed the whole point that I transformed
the HP counter example input into the Liar Paradox.
On 10/10/2025 2:40 AM, Mikko wrote:
On 2025-10-09 16:59:54 +0000, olcott said:
On 10/9/2025 4:35 AM, Mikko wrote:
On 2025-10-09 03:44:33 +0000, olcott said:
On 10/8/2025 4:21 AM, Mikko wrote:
On 2025-10-07 14:27:07 +0000, olcott said:
On 10/7/2025 3:44 AM, Mikko wrote:
On 2025-10-07 00:30:38 +0000, olcott said:
On 10/6/2025 4:41 AM, Mikko wrote:
On 2025-10-05 14:19:02 +0000, olcott said:
On 10/5/2025 4:21 AM, Mikko wrote:
On 2025-10-04 23:03:06 +0000, olcott said:
On 10/4/2025 5:59 PM, Mr Flibble wrote:
Olcott admits that the Halting Problem is undecidable with the following
words quoted verbatim:
DD is the caller of HHH(DD) that does the opposite of whatever HHH(DD)/Flibble
reports. This makes it logically impossible for HHH to correctly report
on the behavior of its caller no matter what HHH does. >>>>>>>>>>>>>>>
So if HHH is asked the question does my caller halt? >>>>>>>>>>>>>>> It is logically impossible for HHH to provide a correct answer. >>>>>>>>>>>>>>
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making H(P) always incorrect.
The problem here is that there is no
actual input that does the above.
If there is no way-a to give the specification of the behaviour of P
to H then H is not a halt decider.
rf?Mrf- Turing machine description of M.
reo* an arbitrary number of moves where a
move is the execution of one TM instruction.
reR the traditional infinite loop at the accept state.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
(a) -n copies its input rf?-nrf-
(b) -n invokes embedded_H rf?-nrf- rf?-nrf-
(c) embedded_H simulates rf?-nrf- rf?-nrf-
(d) rf?-nrf- copies its input rf?-nrf-
(e) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(f) embedded_H simulates rf?-nrf- rf?-nrf-
(h) rf?-nrf- copies its input rf?-nrf-
(i) rf?-nrf- invokes embedded_H rf?-nrf- rf?-nrf-
(j) embedded_H simulates rf?-nrf- rf?-nrf- ...
*Is the only behavior that the actual input has*
When embedded_H transitions to -n.qn that is
the behavior of itself not the behavior of its input.
If the actual input does not specify the behaviour of P then it >>>>>>>>>> is a wrong
By this same fucking reasoning the liar paradox is true.
"This sentence is not true"
(a) Is not true
(b) Says it is not true
(c) Therefore must be true
No, it is not. The sentence "This sentence is not true" cannot be >>>>>>>> assigned any truth value in an interpretation where "this sentence" >>>>>>>> is interpreted to refer to the sentence itself and "is not true" >>>>>>>> is interpreted to mean 'is not true'. But a computation either halts >>>>>>>> or does not halt. I can't do both and it can't avoid both. So the >>>>>>>> question "Does P specify a computation that halts" is a well-posed >>>>>>>> question that has a correct answer.
*Conventional notion of the halting problem proof*
void P()
{
-a-a if H(P)-a // returns 1 for halts 0 for loops
-a-a-a-a HERE: goto HERE;
}
For the set of H/P pairs of
decider H and input P:
If H says halts then P loops
If H says loops then P halts
making each H(P) always incorrect.
Some of them said halts and were wrong
some of them said loops and were wrong
both halts and loops were wrong.
Making the question posed to H: Does P halt?
have the empty set as its solution set.
Nice to see that you don't disagree.
It is modeled after the Liar Paradox so it is really
just a ruse pretending to be a decision problem.
Nevertheless, P() can be encoded as a Turing machine with an empty
input tape and then given to a Turing mahine encoding of H, which
then fails to answer correctly whether P halts.
My DD always has no arguments, thus the same
as an empty tape. When HHH(DD) determines the
halt status specified by the actual behavior
of its actual input by DD correctly simulated
by HHH, the correct halt status is reject.
No, the correct halt status is "halts" because DD halts.
Its like people here are morons.
The executing process that is the caller
of HHH(DD) IS NOT AN INPUT TO HHH and all deciders
ONLY COMPUTE THE MAPPING FROM THEIR INPUTS.