On 2025-11-14, olcott <polcott333@gmail.com> wrote:
int H(char* P);
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
}
Answer only on the basis of performing the
actual simulation of D simulated by H.
When N statements of D are simulated by H
according to the semantics of the C programming
language can the simulated D reach its own "return"
statement final halt state for any value of N?
Positively not. Provided that H returns 0 after the N steps, D reaches
its halt state in N + k steps for some k > 0. Definitely not in the N
steps simulated by H.
But anyway, D terminates in N + k steps, showing that the 0 return
is incorrect. The fact that H only makes it to N, and then returns
the wrong value, is H's problem, and has no bearing on whether D terminates---except to the extent that D's termination depends on
H returning 0.
So you still don't understand that when H sees
that D calls the same function twice in sequence
with the same arguments and has no conditional
code inbetween its invocation and this function
call that this is isomorphic to infinite recursion?
On 2025-11-14, olcott <polcott333@gmail.com> wrote:
So you still don't understand that when H sees
that D calls the same function twice in sequence
with the same arguments and has no conditional
code inbetween its invocation and this function
call that this is isomorphic to infinite recursion?
No. Obvious counterexample:
void D(void)
{
printf("calling this twice\n");
// no conditionals here
printf("calling this twice\n");
}
You're simply not able to run a simple specification through your head
to identify the ways in which it might not reflect your intent.
On 11/13/2025 8:32 PM, Kaz Kylheku wrote:
On 2025-11-14, olcott <polcott333@gmail.com> wrote:
So you still don't understand that when H sees
that D calls the same function twice in sequence
with the same arguments and has no conditional
code inbetween its invocation and this function
call that this is isomorphic to infinite recursion?
No. Obvious counterexample:
void D(void)
{
printf("calling this twice\n");
// no conditionals here
printf("calling this twice\n");
}
You're simply not able to run a simple specification through your head
to identify the ways in which it might not reflect your intent.
Why do you post such ridiculous nonsense?
Are you a complete jackass or only partial?
This is my life's work and you baselessly
denigrate it with stupid shit like resuming
infinite recursion will cause it to halt.
int H(char* P);
int D()
{
ÿ int Halt_Status = H(D);
ÿ if (Halt_Status)
ÿÿÿ HERE: goto HERE;
ÿ return Halt_Status;
}
int main()
{
ÿ H(D);
}
Answer only on the basis of performing the
actual simulation of D simulated by H.
When N statements of D are simulated by H
according to the semantics of the C programming
language can the simulated D reach its own "return"
statement final halt state for any value of N?
If I have to keep posting this every day for
the next ten years I will.
I have been asking for five minutes of someone's
time and they spend thousands of hours dodging this
over more than three years.
On 2025-11-14, olcott <polcott333@gmail.com> wrote:
On 11/13/2025 8:32 PM, Kaz Kylheku wrote:
On 2025-11-14, olcott <polcott333@gmail.com> wrote:
So you still don't understand that when H sees
that D calls the same function twice in sequence
with the same arguments and has no conditional
code inbetween its invocation and this function
call that this is isomorphic to infinite recursion?
No. Obvious counterexample:
void D(void)
{
printf("calling this twice\n");
// no conditionals here
printf("calling this twice\n");
}
You're simply not able to run a simple specification through your head
to identify the ways in which it might not reflect your intent.
Why do you post such ridiculous nonsense?
The above "D calls the same function (printf) twice in sequence with the
same arguments ("calling this twice\n") and has no conditional code
inbetween its invocation and this function call". It meets your
criteria; therefore it must be "isomorphic to infinite recursion".
Are you a complete jackass or only partial?
I'm only conveying to you that the above function meets the words you
have written.
If you didn't intend that, that is your problem. I'm just the messenger.
Such a messenger wouldn't be necessary if you could think for yourself.
This is my life's work and you baselessly
denigrate it with stupid shit like resuming
infinite recursion will cause it to halt.
When your life's work is being reviewed for publication, so that you can become a renowned computer scientist, is this how you are going to
respond to your reviewers, and do you think that will work?
Your idea that when a decider abandons a simulation and returns zero,
the simuation is "totally killed" does not hold water. Mathematical
entities are never "killed".
You should be glad that we caught this problem here, before
you took your life's work to academia for publication.
On 11/14/2025 12:35 AM, Kaz Kylheku wrote:
On 2025-11-14, olcott <polcott333@gmail.com> wrote:
On 11/13/2025 8:32 PM, Kaz Kylheku wrote:
On 2025-11-14, olcott <polcott333@gmail.com> wrote:
So you still don't understand that when H sees
that D calls the same function twice in sequence
with the same arguments and has no conditional
code inbetween its invocation and this function
call that this is isomorphic to infinite recursion?
No. Obvious counterexample:
void D(void)
{
printf("calling this twice\n");
// no conditionals here
printf("calling this twice\n");
}
You're simply not able to run a simple specification through your head >>>> to identify the ways in which it might not reflect your intent.
Why do you post such ridiculous nonsense?
The above "D calls the same function (printf) twice in sequence with the
same arguments ("calling this twice\n") and has no conditional code
inbetween its invocation and this function call". It meets your
criteria; therefore it must be "isomorphic to infinite recursion".
Are you a complete jackass or only partial?
I'm only conveying to you that the above function meets the words you
have written.
OK then I apologize.
If you didn't intend that, that is your problem. I'm just the messenger.
Such a messenger wouldn't be necessary if you could think for yourself.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
I forgot a detail on line 996
Calls the same function from the same machine address
with no conditional branches in between its invocation
and this function call.
Your idea that when a decider abandons a simulation and returns zero,
the simuation is "totally killed" does not hold water. Mathematical
entities are never "killed".
The above non-halting behavior axiom is correct.
It conclusively proves the D simulated by H cannot
possibly ever reach its own simulated "return"
statement.
On 2025-11-14, olcott <polcott333@gmail.com> wrote:
On 11/14/2025 12:35 AM, Kaz Kylheku wrote:
On 2025-11-14, olcott <polcott333@gmail.com> wrote:
On 11/13/2025 8:32 PM, Kaz Kylheku wrote:
On 2025-11-14, olcott <polcott333@gmail.com> wrote:
So you still don't understand that when H sees
that D calls the same function twice in sequence
with the same arguments and has no conditional
code inbetween its invocation and this function
call that this is isomorphic to infinite recursion?
No. Obvious counterexample:
void D(void)
{
printf("calling this twice\n");
// no conditionals here
printf("calling this twice\n");
}
You're simply not able to run a simple specification through your head >>>>> to identify the ways in which it might not reflect your intent.
Why do you post such ridiculous nonsense?
The above "D calls the same function (printf) twice in sequence with the >>> same arguments ("calling this twice\n") and has no conditional code
inbetween its invocation and this function call". It meets your
criteria; therefore it must be "isomorphic to infinite recursion".
Are you a complete jackass or only partial?
I'm only conveying to you that the above function meets the words you
have written.
OK then I apologize.
My eyes must be deceiving me.
If you didn't intend that, that is your problem. I'm just the messenger. >>>
Such a messenger wouldn't be necessary if you could think for yourself.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
I forgot a detail on line 996
Calls the same function from the same machine address
with no conditional branches in between its invocation
and this function call.
Now suppose that we wrongly place execution events from all
threads into a single buffer.
It can now happen like this:
void D(void)
{
(void) thread_create(D);
thread_exit(0);
}
main()
{
(void) thread_create(D);
}
The repeated call in question is D calling thread_create.
The call happens multiple times, from the same address, without
intervening conditional instructions (assuming we do not
trace system functions thread_create and thread_exit).
In our single trace buffer, it /appears/ to meet the conditions for identifying runaway recursion.
Yet, do you not see that the threads are all terminating?
Every single new thread dispatched to D creates a new thread, which is
an asynchronous action, and then promptly terminates.
The /process/ will keep spawning new threads and fail to terminate. But that's not the question. When we ask whether D terminates, we are not
asking whether D is surrounded by a reality which terminates.
Your idea that when a decider abandons a simulation and returns zero,
the simuation is "totally killed" does not hold water. Mathematical
entities are never "killed".
The above non-halting behavior axiom is correct.
It conclusively proves the D simulated by H cannot
possibly ever reach its own simulated "return"
statement.
It doesn't. What is correct is the trick in the halting proof, that no decider could be correct when deciding its diagonal case.
Those who are skeptical can dissect into particular complex cases to see
how they play out: i.e. to articulate in more detail why such and such a diagonal pair case is incorrect. It is largely moot.
In your case, your logic is incorrect even for non-diagonal cases,
such as:
void DDD(void) {
HHH(DDD);
return;
}
For this non-diagonal case, your HHH could return 1 and be correct.
DDD does not behave opposite to the 1 return value; it confirms it.
Assuming that HHH(DDD) "correctly simulates" DDD, and assuming it
does nothing else, your code would be equivalent to this:
void DDD(void) {
DDD();
return;
}
Then the return statement (which is unnecessary anyway) will never be reached. In practice, the program will likely crash due to a stack overflow, unless the compiler implements tail-call optimization, in
which case the program might just run forever -- which also means the unnecessary return statement will never be reached.
| Sysop: | Tetrazocine |
|---|---|
| Location: | Melbourne, VIC, Australia |
| Users: | 14 |
| Nodes: | 8 (0 / 8) |
| Uptime: | 238:01:01 |
| Calls: | 184 |
| Files: | 21,502 |
| Messages: | 82,427 |