On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/19/2025 10:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/19/2025 3:41 PM, Kaz Kylheku wrote:
On 2025-11-19, olcott <polcott333@gmail.com> wrote:that you dishonestly erased most of the context
The sound basis of this reasoning is the
semantics of the C programming language.
... and, note,
That's just the same pseudo-code snppet you've posted
hundreds of times.
The idea is that I will keep repeating this
until you pay attention
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
I've given ths an incredible amount of attention.
HHH simulates DD that calls HHH(DD)
that simulates DD that calls HHH(DD)...
If HHH(DD) returns 0, it's this;
HHH simulates DD that calls HHH(DD)
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- but only partially, returning 0.
- such that DD terminates.
- but only partially, returning 0.
- such that DD terminates.
Adding another level:
HHH simulates DD that calls HHH(DD)
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- that ...
- that ...
- that ...
- but only partially, returning 0.
I don't think that is the shell game. PO really /has/ an H
(it's trivial to do for this one case) that correctly determines
that P(P) *would* never stop running *unless* aborted.
- such that DD terminates.
- but only partially, returning 0.
- such that DD terminates.
- but only partially, returning 0.
- such that DD terminates.
Infinite simulation tower: finite DD's.
Since you don't grok this but I do, obviously the one who has
paid more attention is me.
On 11/20/2025 4:10 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/19/2025 10:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/19/2025 3:41 PM, Kaz Kylheku wrote:
On 2025-11-19, olcott <polcott333@gmail.com> wrote:that you dishonestly erased most of the context
The sound basis of this reasoning is the
semantics of the C programming language.
... and, note,
That's just the same pseudo-code snppet you've posted
hundreds of times.
The idea is that I will keep repeating this
until you pay attention
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
I've given ths an incredible amount of attention.
HHH simulates DD that calls HHH(DD)
that simulates DD that calls HHH(DD)...
If HHH(DD) returns 0, it's this;
HHH simulates DD that calls HHH(DD)
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- but only partially, returning 0.
- such that DD terminates.
- but only partially, returning 0.
- such that DD terminates.
Adding another level:
HHH simulates DD that calls HHH(DD)
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- that ...
- that ...
- that ...
- but only partially, returning 0.
Such a jackass trying to get away with saying
that simulated inputs that cannot possibly stop
running unless aborted terminate normally.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then...
*You are not stupid so that only leaves liar*
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 4:10 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/19/2025 10:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/19/2025 3:41 PM, Kaz Kylheku wrote:
On 2025-11-19, olcott <polcott333@gmail.com> wrote:that you dishonestly erased most of the context
The sound basis of this reasoning is the
semantics of the C programming language.
... and, note,
That's just the same pseudo-code snppet you've posted
hundreds of times.
The idea is that I will keep repeating this
until you pay attention
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
I've given ths an incredible amount of attention.
HHH simulates DD that calls HHH(DD)
that simulates DD that calls HHH(DD)...
If HHH(DD) returns 0, it's this;
HHH simulates DD that calls HHH(DD)
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- but only partially, returning 0.
- such that DD terminates.
- but only partially, returning 0.
- such that DD terminates.
Adding another level:
HHH simulates DD that calls HHH(DD)
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- that ...
- that ...
- that ...
- but only partially, returning 0.
Such a jackass trying to get away with saying
All you have is personal attacks, rather than reasoning
and following code and execution traces.
that simulated inputs that cannot possibly stop
running unless aborted terminate normally.
Self-assurance without a shred of support.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then...
I also agreed to these words, at least four times.
On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 4:10 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/19/2025 10:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/19/2025 3:41 PM, Kaz Kylheku wrote:
On 2025-11-19, olcott <polcott333@gmail.com> wrote:that you dishonestly erased most of the context
The sound basis of this reasoning is the
semantics of the C programming language.
... and, note,
That's just the same pseudo-code snppet you've posted
hundreds of times.
The idea is that I will keep repeating this
until you pay attention
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
I've given ths an incredible amount of attention.
HHH simulates DD that calls HHH(DD)
that simulates DD that calls HHH(DD)...
If HHH(DD) returns 0, it's this;
HHH simulates DD that calls HHH(DD)
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- but only partially, returning 0.
- such that DD terminates.
- but only partially, returning 0.
- such that DD terminates.
Adding another level:
HHH simulates DD that calls HHH(DD)
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- that ...
- that ...
- that ...
- but only partially, returning 0.
Such a jackass trying to get away with saying
All you have is personal attacks, rather than reasoning
and following code and execution traces.
that simulated inputs that cannot possibly stop
running unless aborted terminate normally.
Self-assurance without a shred of support.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then...
I also agreed to these words, at least four times.
I doubt this. Prove it with a
Time/Date stamp and a Message ID.
It must be actual agreement with those
actual words or you are still a liar.
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 4:10 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/19/2025 10:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
On 11/19/2025 3:41 PM, Kaz Kylheku wrote:
On 2025-11-19, olcott <polcott333@gmail.com> wrote:that you dishonestly erased most of the context
The sound basis of this reasoning is the
semantics of the C programming language.
... and, note,
That's just the same pseudo-code snppet you've posted
hundreds of times.
The idea is that I will keep repeating this
until you pay attention
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
I've given ths an incredible amount of attention.
HHH simulates DD that calls HHH(DD)
that simulates DD that calls HHH(DD)...
If HHH(DD) returns 0, it's this;
HHH simulates DD that calls HHH(DD)
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- but only partially, returning 0.
- such that DD terminates.
- but only partially, returning 0.
- such that DD terminates.
Adding another level:
HHH simulates DD that calls HHH(DD)
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- that simulates DD that calls HHH(DD)...
- that ...
- that ...
- that ...
- but only partially, returning 0.
Such a jackass trying to get away with saying
All you have is personal attacks, rather than reasoning
and following code and execution traces.
that simulated inputs that cannot possibly stop
running unless aborted terminate normally.
Self-assurance without a shred of support.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then...
I also agreed to these words, at least four times.
I doubt this. Prove it with a
Time/Date stamp and a Message ID.
Go to Google Groups and search.
It must be actual agreement with those
actual words or you are still a liar.
From the perspective of the aborting H, if we consider how the behavior would change if H were redesigned not to abort, we have to conclude
that the D test case would thereby be redesigned not to terminate. And furthermore that H(D) wouldn't return, so the revised D doesn't even
reach the "do-the-opposite" code. (Of course, those are a different H
and D that must be given different names.)
I don't agree with what you are reading into that; but the statement
Sipser supposedly agreed wth doesn't actually read anything into
anything.
[I see you annoyingly added the comp.lang.c and comp.lang.c++ newsgroups
to the crossposts. I didn't catch it, but I'm double checking and
superseding my articles to remove that.]
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
No, it states that D would be non-halting in the hypothetical situtation >>> in whch H neglected to abort, and just kept simulating.
HHH has no idea that DD is calling itself, HHH
can only see that DD is calling the same function
twice in sequence with no conditional branch in
DD to stop this from infinitely repeating.
It's been explained to you that ths doesn't happen.
Any given invocation of DD makes only one call to HHH
(as anyone can plainly see from its simple code of several
lines!)
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then...
I also agreed to these words, at least four times.
On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
No, it states that D would be non-halting in the hypothetical situtation >>>> in whch H neglected to abort, and just kept simulating.
HHH has no idea that DD is calling itself, HHH
can only see that DD is calling the same function
twice in sequence with no conditional branch in
DD to stop this from infinitely repeating.
It's been explained to you that ths doesn't happen.
Any given invocation of DD makes only one call to HHH
(as anyone can plainly see from its simple code of several
lines!)
Those double-talk weasel words count as lying within
the context of this.
int DD()
{
int Halt_Status = HHH(DD);
On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
No, it states that D would be non-halting in the hypothetical situtation >>>> in whch H neglected to abort, and just kept simulating.
HHH has no idea that DD is calling itself, HHH
can only see that DD is calling the same function
twice in sequence with no conditional branch in
DD to stop this from infinitely repeating.
It's been explained to you that ths doesn't happen.
Any given invocation of DD makes only one call to HHH
(as anyone can plainly see from its simple code of several
lines!)
Those double-talk weasel words count as lying within
the context of this.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then...
I also agreed to these words, at least four times.
The above proves that the input to H(D) does specify
non-halting behavior.
Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
No, it states that D would be non-halting in the hypothetical situtation >>>>> in whch H neglected to abort, and just kept simulating.
HHH has no idea that DD is calling itself, HHH
can only see that DD is calling the same function
twice in sequence with no conditional branch in
DD to stop this from infinitely repeating.
It's been explained to you that ths doesn't happen.
Any given invocation of DD makes only one call to HHH
(as anyone can plainly see from its simple code of several
lines!)
Those double-talk weasel words count as lying within
the context of this.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then...
I also agreed to these words, at least four times.
The above proves that the input to H(D) does specify
non-halting behavior.
All you are communicating is that you have no idea what "prove" means;
where the bar is at for proving something.
On 11/21/2025 1:18 PM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
No, it states that D would be non-halting in the hypothetical situtation >>>>>> in whch H neglected to abort, and just kept simulating.
HHH has no idea that DD is calling itself, HHH
can only see that DD is calling the same function
twice in sequence with no conditional branch in
DD to stop this from infinitely repeating.
It's been explained to you that ths doesn't happen.
Any given invocation of DD makes only one call to HHH
(as anyone can plainly see from its simple code of several
lines!)
Those double-talk weasel words count as lying within
the context of this.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then...
I also agreed to these words, at least four times.
The above proves that the input to H(D) does specify
non-halting behavior.
All you are communicating is that you have no idea what "prove" means;
where the bar is at for proving something.
A proof is ultimately any conclusion derived by
applying correct semantic entailment to a
self-evidently true basis.
The semantics of C and the above function are the
self-evidently true basis.
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 1:18 PM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
No, it states that D would be non-halting in the hypothetical situtation
in whch H neglected to abort, and just kept simulating.
HHH has no idea that DD is calling itself, HHH
can only see that DD is calling the same function
twice in sequence with no conditional branch in
DD to stop this from infinitely repeating.
It's been explained to you that ths doesn't happen.
Any given invocation of DD makes only one call to HHH
(as anyone can plainly see from its simple code of several
lines!)
Those double-talk weasel words count as lying within
the context of this.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>> If simulating halt decider H correctly simulates its input D >>>>>> until H correctly determines that its simulated D would never >>>>>> stop running unless aborted then...
I also agreed to these words, at least four times.
The above proves that the input to H(D) does specify
non-halting behavior.
All you are communicating is that you have no idea what "prove" means;
where the bar is at for proving something.
A proof is ultimately any conclusion derived by
applying correct semantic entailment to a
self-evidently true basis.
You've not even began to do anythng of this sort.
The semantics of C and the above function are the
self-evidently true basis.
The above function is incomplete. You have to show all of
HHHH, and how exactly it simulates DD, and how it comes to
the conclusion that it should stop doing that and return 0.
Those can all be incorrect, without the "semantics of C"
being violated!
Do you not know that a program can be buggy? Or entirely the wrong
program written to the wrong requirements? Yet completely adhere to the semantics of its programming language (whch means never doing anything undefined?)
You've only been a coding technician and not an actual engineer,
that's why you don't know basics like this.
On 11/21/2025 4:05 PM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 1:18 PM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
No, it states that D would be non-halting in the
hypothetical situtation
in whch H neglected to abort, and just kept simulating.
HHH has no idea that DD is calling itself, HHH
can only see that DD is calling the same function
twice in sequence with no conditional branch in
DD to stop this from infinitely repeating.
It's been explained to you that ths doesn't happen.
Any given invocation of DD makes only one call to HHH
(as anyone can plainly see from its simple code of several
lines!)
Those double-talk weasel words count as lying within
the context of this.
int DD()
{
ÿÿÿÿ int Halt_Status = HHH(DD);
ÿÿÿÿ if (Halt_Status)
ÿÿÿÿÿÿ HERE: goto HERE;
ÿÿÿÿ return Halt_Status;
}
On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
ÿÿÿÿÿ If simulating halt decider H correctly simulates its
input D
ÿÿÿÿÿ until H correctly determines that its simulated D
would never
ÿÿÿÿÿ stop running unless aborted then...
I also agreed to these words, at least four times.
The above proves that the input to H(D) does specify
non-halting behavior.
All you are communicating is that you have no idea what
"prove" means;
where the bar is at for proving something.
A proof is ultimately any conclusion derived by
applying correct semantic entailment to a
self-evidently true basis.
You've not even began to do anythng of this sort.
The semantics of C and the above function are the
self-evidently true basis.
The above function is incomplete. You have to show all of
HHHH, and how exactly it simulates DD, and how it comes to
the conclusion that it should stop doing that and return 0.
The combination of the semantics of C
and the source of the function DD provide
all the information needed to specify all
of the details of the steps of DD simulated
by HHH.
On 22/11/2025 05:14, olcott wrote:
On 11/21/2025 4:05 PM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 1:18 PM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
No, it states that D would be non-halting in the hypothetical >>>>>>>>> situtation
in whch H neglected to abort, and just kept simulating.
HHH has no idea that DD is calling itself, HHH
can only see that DD is calling the same function
twice in sequence with no conditional branch in
DD to stop this from infinitely repeating.
It's been explained to you that ths doesn't happen.
Any given invocation of DD makes only one call to HHH
(as anyone can plainly see from its simple code of several
lines!)
Those double-talk weasel words count as lying within
the context of this.
int DD()
{
ÿÿÿÿ int Halt_Status = HHH(DD);
ÿÿÿÿ if (Halt_Status)
ÿÿÿÿÿÿ HERE: goto HERE;
ÿÿÿÿ return Halt_Status;
}
On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
On 2025-11-20, olcott <polcott333@gmail.com> wrote:
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
ÿÿÿÿÿ If simulating halt decider H correctly simulates its input D >>>>>>>> ÿÿÿÿÿ until H correctly determines that its simulated D would never >>>>>>>> ÿÿÿÿÿ stop running unless aborted then...
I also agreed to these words, at least four times.
The above proves that the input to H(D) does specify
non-halting behavior.
All you are communicating is that you have no idea what "prove" means; >>>>> where the bar is at for proving something.
A proof is ultimately any conclusion derived by
applying correct semantic entailment to a
self-evidently true basis.
You've not even began to do anythng of this sort.
The semantics of C and the above function are the
self-evidently true basis.
The above function is incomplete. You have to show all of
HHHH, and how exactly it simulates DD, and how it comes to
the conclusion that it should stop doing that and return 0.
The combination of the semantics of C
and the source of the function DD provide
all the information needed to specify all
of the details of the steps of DD simulated
by HHH.
Not so.
I don't think that is the shell game. PO really /has/ an H
(it's trivial to do for this one case) that correctly determines
that P(P) *would* never stop running *unless* aborted.
HHH could, for example, contain its own exit() call, in which case DD
halts, or its own for(;;); loop, in which case DD doesn't halt... or
even both, in which case it all depends.
Since DD calls HHH, DD's behaviour depends on HHH's behaviour, and any analysis of DD's behaviour must therefore include an analysis of HHH's behaviour.
What you have to remember about olcott is that not only does he have no understanding of DD's specific dependency on HHH (ie whether DD halts depends first and foremost on HHH's coin-toss decision), but neither
does he have any idea of any C function's generic dependency on the functions it calls.
Not only is olcott a damned liar, but he's a damned idiot. He is, in
fact, a fine exemplar of why killfiles were invented. Just plonk him and (barring the odd nymshyft) you can be done with him for good.
<snip>
On 2025-11-22, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 3:58 PM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
Irrelevant to the question wheter H is designed to ask "Does D halt
if fully executed?" when D is the input to H.
It turns out that question is the same as
predict who the next president of the United
States will be entirely on the basis of the
square root of two. That information is not
contained in the input.
Yes it is. It is just too complex for H to use, though.
H has to trace through its own complexity and then some.
The incomptuability of halting is hinged to the problem that programs
cannot completely model their own complexity inside of themselves.
The details of the behavior of D() executed
from main are not in the input to H(D).
Why are they in the input to UTM(D) but not in
the input of H(D)? The argument passing is identical.
You are just bat shit crazy.
It could be of parasitic origin; maybe you have picked up some
sort of rare fungal infection that is producing psychedelics.
On 2025-11-22, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 3:58 PM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
Irrelevant to the question wheter H is designed to ask "Does D halt
if fully executed?" when D is the input to H.
It turns out that question is the same as
predict who the next president of the United
States will be entirely on the basis of the
square root of two. That information is not
contained in the input.
Yes it is. It is just too complex for H to use, though.
H has to trace through its own complexity and then some.
The incomptuability of halting is hinged to the problem that programs
cannot completely model their own complexity inside of themselves.
The details of the behavior of D() executed
from main are not in the input to H(D).
That directly contradicts:
The combination of the semantics of C
and the source of the function DD provide
all the information needed to specify all
of the details of the steps of DD simulated
by HHH.
Under the imaginary C simulation system, a function pointer DD is
source-code based, since it is inside a simulation framwork in whch the current executing position is tracked to the syntax tree.
HHH(DD) receives the DD code, and has access to the simulation
API to step it according to the correct semantics.
What is lacking?
On 11/22/2025 12:49 AM, Kaz Kylheku wrote:
On 2025-11-22, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 3:58 PM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
Irrelevant to the question wheter H is designed to ask "Does D halt >>>>>> if fully executed?" when D is the input to H.
It turns out that question is the same as
predict who the next president of the United
States will be entirely on the basis of the
square root of two. That information is not
contained in the input.
Yes it is. It is just too complex for H to use, though.
H has to trace through its own complexity and then some.
The incomptuability of halting is hinged to the problem that programs
cannot completely model their own complexity inside of themselves.
The details of the behavior of D() executed
from main are not in the input to H(D).
Why are they in the input to UTM(D) but not in
the input of H(D)? The argument passing is identical.
Because D calls H(D) in recursive simulation
this H/D pair has different behavior than H
with any other input and D with any other decider.
is exactly the same as HHH except that DD does not
call HHH1(DD) in recursive simulation.
A guy that is smart enough to do this https://www.nongnu.org/txr/txr-manpage.html#N-CF27E2FE
On 2025-11-22, olcott <polcott333@gmail.com> wrote:
On 11/22/2025 12:49 AM, Kaz Kylheku wrote:
On 2025-11-22, olcott <polcott333@gmail.com> wrote:
On 11/21/2025 3:58 PM, Kaz Kylheku wrote:
On 2025-11-21, olcott <polcott333@gmail.com> wrote:
Irrelevant to the question wheter H is designed to ask "Does D halt >>>>>>> if fully executed?" when D is the input to H.
It turns out that question is the same as
predict who the next president of the United
States will be entirely on the basis of the
square root of two. That information is not
contained in the input.
Yes it is. It is just too complex for H to use, though.
H has to trace through its own complexity and then some.
The incomptuability of halting is hinged to the problem that programs >>>>> cannot completely model their own complexity inside of themselves.
The details of the behavior of D() executed
from main are not in the input to H(D).
Why are they in the input to UTM(D) but not in
the input of H(D)? The argument passing is identical.
Because D calls H(D) in recursive simulation
this H/D pair has different behavior than H
with any other input and D with any other decider.
We are concerned only with the behavior of D; the behavior of D does not depend on the choice of decider that we apply to D.
The behavior of D is based on the H/D pair.
| Sysop: | Tetrazocine |
|---|---|
| Location: | Melbourne, VIC, Australia |
| Users: | 14 |
| Nodes: | 8 (0 / 8) |
| Uptime: | 238:03:47 |
| Calls: | 184 |
| Files: | 21,502 |
| Messages: | 82,427 |