As olcott had found recently, the 1,0 decision codes in HP is actually unreachable dead codes.
On 2025-09-14 18:29:40 +0000, wij said:Correct. It is not dead code. The simplified proof is wrong. Thanks. Undecidable and self-reference are not exactly the same.
As olcott had found recently, the 1,0 decision codes in HP is actually unreachable dead codes.
No, it is not. HP is about halting and nothing else. But both the halting problem and the dead code problem are special cases of reachability
problems. If a full reachability analysis can be performed then that
answers both the halting and dead code questions.
As olcott had found recently, the 1,0 decision codes in HP is actually unreachable dead codes. The HP proof can be simplified as:
extern int HHH(void (*)()); // the claimed halt decider. Also a suggest, making
 // HHH external can improve the quality of POOH
void DD() {
HHH(DD);
}
int main() {
HHH(DD); // Does HHH halt?
}
HHH (in main) is obviously an infinite recurrsive call. It cannot return. Thus, Halt Problem is undecidable.
'undecidable' really means an endless loop, not the toggle of 1's and 0's. E.g. The decision of truth value of "this sentence is true" is also undecidable,
though not looking paradoxical. It is because the 'not looking paradoxical', many proofs or even theorem are actually based on self-referencial reasoning, e.g. Dedekind's real number theory, Cantor's set theory (and many POOH arguments
are also self-referencial).
On Mon, 2025-09-15 at 11:24 +0300, Mikko wrote:
On 2025-09-14 18:29:40 +0000, wij said:
As olcott had found recently, the 1,0 decision codes in HP is actually
unreachable dead codes.
No, it is not. HP is about halting and nothing else. But both the halting
problem and the dead code problem are special cases of reachability
problems. If a full reachability analysis can be performed then that
answers both the halting and dead code questions.
Correct. It is not dead code. The simplified proof is wrong. Thanks.
Undecidable and self-reference are not exactly the same.
People have been essentially brainwashed to believe
that a halt decider is supposed to report on something
besides the actual behavior that they actual input
On 9/14/2025 1:29 PM, wij wrote:
As olcott had found recently, the 1,0 decision codes in HP is actually
unreachable dead codes. The HP proof can be simplified as:
extern int HHH(void (*)()); // the claimed halt decider. Also a suggest, making
 // HHH external can improve the quality of POOH
void DD() {
HHH(DD);
}
int main() {
HHH(DD); // Does HHH halt?
}
HHH (in main) is obviously an infinite recurrsive call. It cannot return.
Thus, Halt Problem is undecidable.
*I do this same thing with*
void DDD()
{
HHH(DDD);
return;
}
Simulating Termination analyzer HHH(DDD)
returns 0 because
On 2025-09-15, olcott <polcott333@gmail.com> wrote:
People have been essentially brainwashed to believe
that a halt decider is supposed to report on something
besides the actual behavior that they actual input
In your apparatus, the simulated halt decider is peeking
at a prior execution trace, not related to its input.
Just by copy and pasting the decider function and changing
its name, you obtain different results.
Your shit is positively /not/ sticking to the doctrine of
"actual behavior of actual input".
On 2025-09-15, olcott <polcott333@gmail.com> wrote:
On 9/14/2025 1:29 PM, wij wrote:
As olcott had found recently, the 1,0 decision codes in HP is actually
unreachable dead codes. The HP proof can be simplified as:
extern int HHH(void (*)()); // the claimed halt decider. Also a suggest, making
 // HHH external can improve the quality of POOH
void DD() {
HHH(DD);
}
int main() {
HHH(DD); // Does HHH halt?
}
HHH (in main) is obviously an infinite recurrsive call. It cannot return. >>> Thus, Halt Problem is undecidable.
*I do this same thing with*
void DDD()
{
HHH(DDD);
return;
}
Note that this is not exactly the diagonal "do the opposite" test case!
Here, HHH(DDD) has the opportunity of correctly returning 1.
Simulating Termination analyzer HHH(DDD)
returns 0 because
If HHH(DDD) returns 0, it means HHH(DDD) returns.
If HHH(DD) returns, it means the above DDD reaches its return
statement; i.e. terminates.
So 0 is incorrect.
Your shit cannot correctly decide even a trivial non-diagonal test
case, if it only carries the vague scent of being a diagnoal
test case by virtue of making a call to HHH(DDD).
On 9/15/2025 12:33 PM, Kaz Kylheku wrote:
On 2025-09-15, olcott <polcott333@gmail.com> wrote:void Infinite_Recursion()
People have been essentially brainwashed to believe that a halt
decider is supposed to report on something besides the actual behavior
that they actual input
In your apparatus, the simulated halt decider is peeking at a prior
execution trace, not related to its input.
{
Infinite_Recursion();
return;
}
Because you are absolutely not going to believe me and you are a very
smart guy I challenge you to derive all of the execution trace details
of the criteria that HHH must use to conclusively prove that Infinite_Recursion() never halts.
Just by copy and pasting the decider function and changing its name,
you obtain different results.
Your shit is positively /not/ sticking to the doctrine of "actual
behavior of actual input".
On 9/15/2025 12:36 PM, Kaz Kylheku wrote:
On 2025-09-15, olcott <polcott333@gmail.com> wrote:
On 9/14/2025 1:29 PM, wij wrote:
As olcott had found recently, the 1,0 decision codes in HP is*I do this same thing with*
actually unreachable dead codes. The HP proof can be simplified as:
extern int HHH(void (*)()); // the claimed halt decider. Also a
suggest, making
 // HHH external can improve the quality of POOH
void DD() {
HHH(DD);
}
int main() {
HHH(DD); // Does HHH halt?
}
HHH (in main) is obviously an infinite recurrsive call. It cannot
return.
Thus, Halt Problem is undecidable.
void DDD()
{
HHH(DDD);
return;
}
Note that this is not exactly the diagonal "do the opposite" test case!
THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR
THAT THE ACTUAL INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE
ACTUAL INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE ACTUAL
INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT
ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES
THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR
THAT THE ACTUAL INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE
ACTUAL INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE ACTUAL
INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT
ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES
Here, HHH(DDD) has the opportunity of correctly returning 1.
Simulating Termination analyzer HHH(DDD)
returns 0 because
If HHH(DDD) returns 0, it means HHH(DDD) returns.
If HHH(DD) returns, it means the above DDD reaches its return
statement; i.e. terminates.
So 0 is incorrect.
Your shit cannot correctly decide even a trivial non-diagonal test
case, if it only carries the vague scent of being a diagnoal test case
by virtue of making a call to HHH(DDD).
On 9/15/2025 12:36 PM, Kaz Kylheku wrote:
On 2025-09-15, olcott <polcott333@gmail.com> wrote:
On 9/14/2025 1:29 PM, wij wrote:
As olcott had found recently, the 1,0 decision codes in HP is actually >>>> unreachable dead codes. The HP proof can be simplified as:
extern int HHH(void (*)()); // the claimed halt decider. Also a suggest, making
 // HHH external can improve the quality of POOH
void DD() {
HHH(DD);
}
int main() {
HHH(DD); // Does HHH halt?
}
HHH (in main) is obviously an infinite recurrsive call. It cannot return. >>>> Thus, Halt Problem is undecidable.
*I do this same thing with*
void DDD()
{
HHH(DDD);
return;
}
Note that this is not exactly the diagonal "do the opposite" test case!
THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES
On 2025-09-15, olcott <polcott333@gmail.com> wrote:
On 9/15/2025 12:36 PM, Kaz Kylheku wrote:
On 2025-09-15, olcott <polcott333@gmail.com> wrote:
On 9/14/2025 1:29 PM, wij wrote:
As olcott had found recently, the 1,0 decision codes in HP is actually >>>>> unreachable dead codes. The HP proof can be simplified as:
extern int HHH(void (*)()); // the claimed halt decider. Also a suggest, making
 // HHH external can improve the quality of POOH
void DD() {
HHH(DD);
}
int main() {
HHH(DD); // Does HHH halt?
}
HHH (in main) is obviously an infinite recurrsive call. It cannot return. >>>>> Thus, Halt Problem is undecidable.
*I do this same thing with*
void DDD()
{
HHH(DDD);
return;
}
Note that this is not exactly the diagonal "do the opposite" test case!
THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES
The actual behavior that the above actual input specifies is
terminating,
... The HP proof can be simplified as:
extern int HHH(void (*)()); // the claimed halt decider. Also a
suggest, making
// HHH external can improve the quality of POOH
void DD() {
HHH(DD);
}
int main() {
HHH(DD); // Does HHH halt?
}
HHH (in main) is obviously an infinite recurrsive call. It cannot
return.
Thus, Halt Problem is undecidable.
On 9/15/2025 2:33 PM, Kaz Kylheku wrote:
On 2025-09-15, olcott <polcott333@gmail.com> wrote:
On 9/15/2025 12:36 PM, Kaz Kylheku wrote:
On 2025-09-15, olcott <polcott333@gmail.com> wrote:
On 9/14/2025 1:29 PM, wij wrote:
As olcott had found recently, the 1,0 decision codes in HP is
actually
unreachable dead codes. The HP proof can be simplified as:
extern int HHH(void (*)());Â // the claimed halt decider. Also a >>>>>> suggest, making
   // HHH external can improve the quality of POOH
void DD() {
   HHH(DD);
}
int main() {
   HHH(DD);       // Does HHH halt?
}
HHH (in main) is obviously an infinite recurrsive call. It cannot >>>>>> return.
Thus, Halt Problem is undecidable.
*I do this same thing with*
void DDD()
{
    HHH(DDD);
    return;
}
Note that this is not exactly the diagonal "do the opposite" test case! >>>
THE ACTUAL BEHAVIOR THAT THE ACTUAL INPUT ACTUALLY SPECIFIES
The actual behavior that the above actual input specifies is
terminating,
void Infinite_Recursion()
{
 Infinite_Recursion();
 return;
}
Then I must insist that you figure out the execution
trace criteria that HHH would use to prove that its
of simulation of Infinite_Recursion is definitely not
halting before we proceed.
On Mon, 2025-09-15 at 11:24 +0300, Mikko wrote:
On 2025-09-14 18:29:40 +0000, wij said:
As olcott had found recently, the 1,0 decision codes in HP is actually
unreachable dead codes.
No, it is not. HP is about halting and nothing else. But both the halting
problem and the dead code problem are special cases of reachability
problems. If a full reachability analysis can be performed then that
answers both the halting and dead code questions.
Correct. It is not dead code. The simplified proof is wrong. Thanks.
Undecidable and self-reference are not exactly the same.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,070 |
| Nodes: | 10 (0 / 10) |
| Uptime: | 161:05:23 |
| Calls: | 13,734 |
| Calls today: | 2 |
| Files: | 186,966 |
| D/L today: |
843 files (303M bytes) |
| Messages: | 2,418,725 |