On 10/29/25 4:25 PM, Chris M. Thomasson wrote:
On 10/28/2025 6:57 PM, Richard Damon wrote:
On 10/28/25 10:51 AM, olcott wrote:
On 10/28/2025 4:41 AM, joes wrote:
Am Sun, 26 Oct 2025 09:56:25 -0500 schrieb olcott:
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:HHH does abort though and returns 1 to DD.
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. He knows and
accepts that
P(P) actually does stop. The wrong answer is justified by what >>>>>>> would
happen if H (and hence a different P) where not what they
actually are.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
When simulating halt decider H is reporting on the
behavior that its input specifies then H is correct
to reject D as non-halting.
Wrong, as the behavior the input specifies is that behavior when the
program is run, and that behavior is based on calling this H, thatg
DOES abort and return 0, and thus the behavior of the program is
halting.
DD can either halt or not halt depending on the result from HHH(DD).
Since HHH(DD) returns an int and its a moron. Well, just fuzz the
little shit. It can hit all paths in DD, halt or not halt.
[...]
But a GIVEN DD will do one or the other as the GIVEN HHH will do
something specific for HHH(DD).
Since the construction definition of DD, was to START with a specific
HHH, you can't start to ask the question until you have chosen what
exactly is HHH.
THis is Olcott's probelm, he can't actually define his HHH, as his
arguement doesn't work with it actually defined, it needs to stay on a slippery slope, which means he can't actually follow the proof.
On 10/29/2025 5:35 AM, Mikko wrote:
On 2025-10-28 09:41:56 +0000, joes said:
Am Sun, 26 Oct 2025 09:56:25 -0500 schrieb olcott:
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:And you think it’s impossible to programmatically determine that DD halts?
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. He knows and accepts that >>>>> P(P) actually does stop. The wrong answer is justified by what would >>>>> happen if H (and hence a different P) where not what they actually are. >>> HHH does abort though and returns 1 to DD.
*This is Claude AI summarizing my rebuttal of Ben's words*
The philosophical point: A Turing machine decider should only be
expected to report on properties determinable from its input. When the >>>> halting problem construction makes the "actual behavior"
dependent on the decider's output, it's asking the decider to report on >>>> something outside its input - hence, a category error.
*Every* single program is decidable.
To determine that DD halts is not merely possible but easy. Just simulate
it until it halts (which doesn't take a long time) and there it is. The
same with any other camputaion that halts, though the time to find out
may be linger.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Ignorance must be bliss for you.
--The hard problem is to find a proof that a computation does not halt.
Even that is not hard for every non-halting computation but it is
for some.
On 2025-10-29 16:41:32 +0000, olcott said:
On 10/29/2025 5:35 AM, Mikko wrote:
On 2025-10-28 09:41:56 +0000, joes said:
Am Sun, 26 Oct 2025 09:56:25 -0500 schrieb olcott:
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:HHH does abort though and returns 1 to DD.
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. He knows and accepts >>>>>> that
P(P) actually does stop. The wrong answer is justified by what would >>>>>> happen if H (and hence a different P) where not what they actually >>>>>> are.
*This is Claude AI summarizing my rebuttal of Ben's words*And you think it’s impossible to programmatically determine that DD >>>> halts?
The philosophical point: A Turing machine decider should only be
expected to report on properties determinable from its input. When the >>>>> halting problem construction makes the "actual behavior"
dependent on the decider's output, it's asking the decider to
report on
something outside its input - hence, a category error.
*Every* single program is decidable.
To determine that DD halts is not merely possible but easy. Just
simulate
it until it halts (which doesn't take a long time) and there it is. The
same with any other camputaion that halts, though the time to find out
may be linger.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
And what happens if it sees?
Ignorance must be bliss for you.
Irrelevant, as you didn't disagree with my comment.
The hard problem is to find a proof that a computation does not halt.
Even that is not hard for every non-halting computation but it is
for some.
On 10/30/2025 5:10 AM, Mikko wrote:
On 2025-10-29 16:41:32 +0000, olcott said:
On 10/29/2025 5:35 AM, Mikko wrote:
On 2025-10-28 09:41:56 +0000, joes said:
Am Sun, 26 Oct 2025 09:56:25 -0500 schrieb olcott:
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:And you think it’s impossible to programmatically determine that DD halts?
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. He knows and accepts that
P(P) actually does stop. The wrong answer is justified by what would >>>>>>> happen if H (and hence a different P) where not what they actually are. >>>>> HHH does abort though and returns 1 to DD.
*This is Claude AI summarizing my rebuttal of Ben's words*
The philosophical point: A Turing machine decider should only be
expected to report on properties determinable from its input. When the >>>>>> halting problem construction makes the "actual behavior"
dependent on the decider's output, it's asking the decider to report on >>>>>> something outside its input - hence, a category error.
*Every* single program is decidable.
To determine that DD halts is not merely possible but easy. Just simulate >>>> it until it halts (which doesn't take a long time) and there it is. The >>>> same with any other camputaion that halts, though the time to find out >>>> may be linger.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
And what happens if it sees?
D simulated by H according to the semantics
of the C programming language until H correctly
determines that its simulated D cannot possibly
reach its own simulated "return" statement
correctly rejects D on this basis not some other
basis.
On 2025-10-30 13:08:12 +0000, olcott said:
On 10/30/2025 5:10 AM, Mikko wrote:
On 2025-10-29 16:41:32 +0000, olcott said:
On 10/29/2025 5:35 AM, Mikko wrote:
On 2025-10-28 09:41:56 +0000, joes said:
Am Sun, 26 Oct 2025 09:56:25 -0500 schrieb olcott:
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:HHH does abort though and returns 1 to DD.
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. He knows and
accepts that
P(P) actually does stop. The wrong answer is justified by what >>>>>>>> would
happen if H (and hence a different P) where not what they
actually are.
*This is Claude AI summarizing my rebuttal of Ben's words*And you think it’s impossible to programmatically determine that >>>>>> DD halts?
The philosophical point: A Turing machine decider should only be >>>>>>> expected to report on properties determinable from its input.
When the
halting problem construction makes the "actual behavior"
dependent on the decider's output, it's asking the decider to
report on
something outside its input - hence, a category error.
*Every* single program is decidable.
To determine that DD halts is not merely possible but easy. Just
simulate
it until it halts (which doesn't take a long time) and there it is. >>>>> The
same with any other camputaion that halts, though the time to find out >>>>> may be linger.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
And what happens if it sees?
D simulated by H according to the semantics
of the C programming language until H correctly
determines that its simulated D cannot possibly
reach its own simulated "return" statement
correctly rejects D on this basis not some other
basis.
This is possible except the word "correctly". But that is not the
last thing that happens. Then H returns zero to its caller, which
in this case is D, and D returns the zero to the program that
called D. Because D halts the rejection by H is not correct, and
therefore we can observe that H is not a halt decider.
On 10/31/2025 6:23 AM, Mikko wrote:
On 2025-10-30 13:08:12 +0000, olcott said:
On 10/30/2025 5:10 AM, Mikko wrote:
On 2025-10-29 16:41:32 +0000, olcott said:
On 10/29/2025 5:35 AM, Mikko wrote:
On 2025-10-28 09:41:56 +0000, joes said:
Am Sun, 26 Oct 2025 09:56:25 -0500 schrieb olcott:
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:HHH does abort though and returns 1 to DD.
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. He knows and accepts that
P(P) actually does stop. The wrong answer is justified by what would
happen if H (and hence a different P) where not what they actually are.
*This is Claude AI summarizing my rebuttal of Ben's words*And you think it’s impossible to programmatically determine that DD halts?
The philosophical point: A Turing machine decider should only be >>>>>>>> expected to report on properties determinable from its input. When the >>>>>>>> halting problem construction makes the "actual behavior"
dependent on the decider's output, it's asking the decider to report on
something outside its input - hence, a category error.
*Every* single program is decidable.
To determine that DD halts is not merely possible but easy. Just simulate
it until it halts (which doesn't take a long time) and there it is. The >>>>>> same with any other camputaion that halts, though the time to find out >>>>>> may be linger.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
And what happens if it sees?
D simulated by H according to the semantics
of the C programming language until H correctly
determines that its simulated D cannot possibly
reach its own simulated "return" statement
correctly rejects D on this basis not some other
basis.
This is possible except the word "correctly". But that is not the
last thing that happens. Then H returns zero to its caller, which
in this case is D, and D returns the zero to the program that
called D. Because D halts the rejection by H is not correct, and
therefore we can observe that H is not a halt decider.
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
On 2025-10-31 12:21:55 +0000, olcott said:
On 10/31/2025 6:23 AM, Mikko wrote:
On 2025-10-30 13:08:12 +0000, olcott said:
On 10/30/2025 5:10 AM, Mikko wrote:
On 2025-10-29 16:41:32 +0000, olcott said:
On 10/29/2025 5:35 AM, Mikko wrote:
On 2025-10-28 09:41:56 +0000, joes said:
Am Sun, 26 Oct 2025 09:56:25 -0500 schrieb olcott:
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:HHH does abort though and returns 1 to DD.
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. He knows and >>>>>>>>>> accepts that
P(P) actually does stop. The wrong answer is justified by >>>>>>>>>> what would
happen if H (and hence a different P) where not what they >>>>>>>>>> actually are.
*This is Claude AI summarizing my rebuttal of Ben's words*And you think it’s impossible to programmatically determine that >>>>>>>> DD halts?
The philosophical point: A Turing machine decider should only be >>>>>>>>> expected to report on properties determinable from its input. >>>>>>>>> When the
halting problem construction makes the "actual behavior"
dependent on the decider's output, it's asking the decider to >>>>>>>>> report on
something outside its input - hence, a category error.
*Every* single program is decidable.
To determine that DD halts is not merely possible but easy. Just >>>>>>> simulate
it until it halts (which doesn't take a long time) and there it >>>>>>> is. The
same with any other camputaion that halts, though the time to
find out
may be linger.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
And what happens if it sees?
D simulated by H according to the semantics
of the C programming language until H correctly
determines that its simulated D cannot possibly
reach its own simulated "return" statement
correctly rejects D on this basis not some other
basis.
This is possible except the word "correctly". But that is not the
last thing that happens. Then H returns zero to its caller, which
in this case is D, and D returns the zero to the program that
called D. Because D halts the rejection by H is not correct, and
therefore we can observe that H is not a halt decider.
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
There is only one D above.
On 11/1/2025 4:51 AM, Mikko wrote:
On 2025-10-31 12:21:55 +0000, olcott said:
On 10/31/2025 6:23 AM, Mikko wrote:
On 2025-10-30 13:08:12 +0000, olcott said:
On 10/30/2025 5:10 AM, Mikko wrote:
On 2025-10-29 16:41:32 +0000, olcott said:
On 10/29/2025 5:35 AM, Mikko wrote:
On 2025-10-28 09:41:56 +0000, joes said:
Am Sun, 26 Oct 2025 09:56:25 -0500 schrieb olcott:
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:HHH does abort though and returns 1 to DD.
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. He knows and accepts that
P(P) actually does stop. The wrong answer is justified by what would
happen if H (and hence a different P) where not what they actually are.
*This is Claude AI summarizing my rebuttal of Ben's words*And you think it’s impossible to programmatically determine that DD halts?
The philosophical point: A Turing machine decider should only be >>>>>>>>>> expected to report on properties determinable from its input. When the
halting problem construction makes the "actual behavior"
dependent on the decider's output, it's asking the decider to report on
something outside its input - hence, a category error.
*Every* single program is decidable.
To determine that DD halts is not merely possible but easy. Just simulate
it until it halts (which doesn't take a long time) and there it is. The
same with any other camputaion that halts, though the time to find out >>>>>>>> may be linger.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
And what happens if it sees?
D simulated by H according to the semantics
of the C programming language until H correctly
determines that its simulated D cannot possibly
reach its own simulated "return" statement
correctly rejects D on this basis not some other
basis.
This is possible except the word "correctly". But that is not the
last thing that happens. Then H returns zero to its caller, which
in this case is D, and D returns the zero to the program that
called D. Because D halts the rejection by H is not correct, and
therefore we can observe that H is not a halt decider.
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
D simulated by H Not D executed from main()
There is only one D above.
Thousands of times I refer to D simulated by H
and despicably dishonest people use the despicably
dishonest tactic of strawman to refer to the directly
executed D as their rebuttal.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,075 |
| Nodes: | 10 (0 / 10) |
| Uptime: | 90:34:45 |
| Calls: | 13,798 |
| Calls today: | 1 |
| Files: | 186,989 |
| D/L today: |
5,331 files (1,536M bytes) |
| Messages: | 2,438,212 |