Simulating Termination Analyzer HHH correctly simulates its input until:394345150_Halting_Problem_Simulation_Paradox
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/publication/
*Same analysis by ChatGPT* https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9ceedd0f09e141
*Same analysis by Grok* https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
On 8/6/2025 1:38 PM, Mr Flibble wrote:
On Wed, 06 Aug 2025 13:34:33 -0500, olcott wrote:
Simulating Termination Analyzer HHH correctly simulates its input394345150_Halting_Problem_Simulation_Paradox
until:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return
1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/publication/
eedd0f09e141
*Same analysis by ChatGPT*
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok*
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
HHH is a partial decider, we are only concerned with total deciders
when discussing the Halting Problem.
/Flibble
*The quality of this reply was perfect*
On 8/6/2025 12:38 PM, Mr Flibble wrote:
No, the proofs are asking if such a halt decider exists so it is a *premise* (a statement that is provisionally accepted as true for the purpose of the argument) that a *hypothetical* H exists and the
proofs then go on to [ATTEMPT TO] show that such an H cannot exist.
They do this by deriving an input that no partial halt decider can
correctly decide.
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/ publication/394345150_Halting_Problem_Simulation_Paradox
*Same analysis by ChatGPT* https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok* https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
On 8/6/2025 1:38 PM, Mr Flibble wrote:
On Wed, 06 Aug 2025 13:34:33 -0500, olcott wrote:
Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) Detects a non-terminating behavior pattern: abort simulation and394345150_Halting_Problem_Simulation_Paradox
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/publication/
eedd0f09e141
*Same analysis by ChatGPT*
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok*
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
HHH is a partial decider, we are only concerned with total deciders when
discussing the Halting Problem.
/Flibble
*The quality of this reply was perfect*
On 8/6/2025 12:38 PM, Mr Flibble wrote:
No, the proofs are asking if such a halt decider exists so it is a *premise* (a statement that is provisionally accepted as true for the purpose of the argument) that a *hypothetical* H exists and the proofs then go on to [ATTEMPT TO] show that such an H cannot exist.
They do this by deriving an input that no partial halt decider
can correctly decide.
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/ publication/394345150_Halting_Problem_Simulation_Paradox
*Same analysis by ChatGPT* https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok* https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
On 8/6/2025 8:37 PM, Richard Damon wrote:Telling incorrect information, by leaving out the actual fact that also
On 8/6/25 2:34 PM, olcott wrote:
Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
Except that YOUR HHH doesn't do that, as the pattern it detects is
part of a Halting Program, so isn't a Non-Halting Pattern.
Of course, since you have admitted that all your claims are based on
LYING that you are actually working on the halting problem, we can't
know what you actaully are meaning, since you start with a contradiciton.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
The opposite of what it does.
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/
publication/394345150_Halting_Problem_Simulation_Paradox
*Same analysis by ChatGPT*
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok*
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
Which all start with a LIE, as you omit what its ACTUAL actual would
be based on the first two rules, that it can run forever, there is no
certainty that either of the first two conditions will be meet.
Sorry, but all you are doing is proving that you are too stupid to
understand the error, and are now rejoicing that you have found
someone else more stupid than you, even if it never claimed to have
any real intelligence.
Of course, you have admitted that apparently you have spent a lot of
time trying to fashion your question in a way thet gives you the
answer you want, so it isn't a fair test.
How many times have you NOT gotten an answer you wanted?
Of course, you just threw those away.
I have gotten the answer that I wanted at least 15 times
and not gotten it only once. Those 15 times were far too
verbose for anyone to carefully analyze.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
</Input to LLM systems>
On 8/6/2025 8:37 PM, Richard Damon wrote:
On 8/6/25 2:34 PM, olcott wrote:
Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
Except that YOUR HHH doesn't do that, as the pattern it detects is
part of a Halting Program, so isn't a Non-Halting Pattern.
Of course, since you have admitted that all your claims are based on
LYING that you are actually working on the halting problem, we can't
know what you actaully are meaning, since you start with a contradiciton.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
The opposite of what it does.
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/
publication/394345150_Halting_Problem_Simulation_Paradox
*Same analysis by ChatGPT*
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok*
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
Which all start with a LIE, as you omit what its ACTUAL actual would
be based on the first two rules, that it can run forever, there is no
certainty that either of the first two conditions will be meet.
Sorry, but all you are doing is proving that you are too stupid to
understand the error, and are now rejoicing that you have found
someone else more stupid than you, even if it never claimed to have
any real intelligence.
Of course, you have admitted that apparently you have spent a lot of
time trying to fashion your question in a way thet gives you the
answer you want, so it isn't a fair test.
How many times have you NOT gotten an answer you wanted?
Of course, you just threw those away.
I have gotten the answer that I wanted at least 15 times
and not gotten it only once. Those 15 times were far too
verbose for anyone to carefully analyze.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
</Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input
until:
(a) Detects a non-terminating behavior pattern: abort simulation
and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
On 8/7/2025 11:24 AM, Richard Heathfield wrote:
Let's consider all possible cases. There are only two cases ---
HHH should report either a halt or a forever loop.
CASE ONE: DD NEVER RETURNS
--------------------------
If DD never halts (doesn't return), HHH must return 0, so
if(Halt_Status) will fail, and DD will return - a
contradiction, so our assumption is false.
*I am so happy that you are going over this with me, thanks*
As three LLM systems figured out on their own without prompting
DD correctly simulated by HHH matches the recursive simulation
non-halting behavior pattern. (see links below)
This means that the actual *input* to HHH(DD) specifies a
sequence of correctly simulated instructions that cannot
possibly reach its own correctly simulated final halt state.
Termination analyzers are only required to report on the...and get it right, which yours clearly doesn't because (as
behavior that their input specifies.
Non-inputs are not
in the domain of HHH, thus the behavior of DD() does
not actually contradict the return value of HHH(DD).
On 8/7/2025 12:18 PM, Richard Heathfield wrote:
On 07/08/2025 17:50, olcott wrote:
Non-inputs are not
in the domain of HHH, thus the behavior of DD() does
not actually contradict the return value of HHH(DD).
If DD is a non-input, HHH(DD) can't have been called, so HHH
can't have correctly simulated anything, so it isn't a simulator.
It is a very subtle point
If you are unwilling to understand this key aspect of my
system then it would seem that you don't really want an
honest dialogue.
You have to make up your mind - are you claiming to pass DD to
HHH as its input, or aren't you?
*I have spent 22 years on this. I do know the proof*
On 8/7/2025 1:35 PM, Richard Heathfield wrote:
On 07/08/2025 19:27, olcott wrote:
<snip>
*I have spent 22 years on this. I do know the proof*
Then you know you're wrong (or you don't know the proof).
Not at all.
The recursive simulation non-halting behavior pattern
allowed my HHH(DD) to correctly compute the mapping
*FROM ITS ACTUAL INPUT* to the non-halting behavior
*THAT THIS INPUT SPECIFIES*
Like everyone else you would much rather spend hundreds
of hours disagreeing than five minutes of understanding.
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
On 07/08/2025 19:41, olcott wrote:If you bothered to understand the recursive emulation non-halting
On 8/7/2025 1:35 PM, Richard Heathfield wrote:
On 07/08/2025 19:27, olcott wrote:Not at all.
<snip>
*I have spent 22 years on this. I do know the proof*
Then you know you're wrong (or you don't know the proof).
The recursive simulation non-halting behavior pattern allowed my
HHH(DD) to correctly compute the mapping *FROM ITS ACTUAL INPUT* to
the non-halting behavior *THAT THIS INPUT SPECIFIES*
That's nice.
Like everyone else you would much rather spend hundreds of hours
disagreeing than five minutes of understanding.
Think about it.
You know from logic that HHH cannot possibly simulate DD's full
behaviour because it isn't until after HHH has finished its work and
returned that DD makes the decision to divert or not divert into its
forever loop.
behavior pattern you would see that DD correctly simulated by HHH cannot possibly reach its own "if" statement.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
On 8/7/2025 3:55 PM, Mr Flibble wrote:That's what he said.
On Thu, 07 Aug 2025 15:39:54 -0500, olcott wrote:
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
You know from logic that HHH cannot possibly simulate DD's fullIf you bothered to understand the recursive emulation non-halting
behaviour because it isn't until after HHH has finished its work and
returned that DD makes the decision to divert or not divert into its
forever loop.
behavior pattern you would see that DD correctly simulated by HHH
cannot possibly reach its own "if" statement.
The other instances aren't deciders.If the halt decider cannot return a decision result to its caller thenThe outermost instance of HHH always returns a result to its caller for
it isn't a halt decider.
every input in its domain.
On 8/7/2025 3:55 PM, Mr Flibble wrote:
On Thu, 07 Aug 2025 15:39:54 -0500, olcott wrote:
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
On 07/08/2025 19:41, olcott wrote:If you bothered to understand the recursive emulation non-halting
On 8/7/2025 1:35 PM, Richard Heathfield wrote:
On 07/08/2025 19:27, olcott wrote:Not at all.
<snip>
*I have spent 22 years on this. I do know the proof*
Then you know you're wrong (or you don't know the proof).
The recursive simulation non-halting behavior pattern allowed my
HHH(DD) to correctly compute the mapping *FROM ITS ACTUAL INPUT* to
the non-halting behavior *THAT THIS INPUT SPECIFIES*
That's nice.
Like everyone else you would much rather spend hundreds of hours
disagreeing than five minutes of understanding.
Think about it.
You know from logic that HHH cannot possibly simulate DD's full
behaviour because it isn't until after HHH has finished its work and
returned that DD makes the decision to divert or not divert into its
forever loop.
behavior pattern you would see that DD correctly simulated by HHH
cannot possibly reach its own "if" statement.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
If the halt decider cannot return a decision result to its caller then
it isn't a halt decider.
/Flibble
The outermost instance of HHH always returns a result to its caller for
every input in its domain.
On 8/7/2025 4:05 PM, Mr Flibble wrote:
On Thu, 07 Aug 2025 16:00:17 -0500, olcott wrote:
On 8/7/2025 3:55 PM, Mr Flibble wrote:
On Thu, 07 Aug 2025 15:39:54 -0500, olcott wrote:
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
On 07/08/2025 19:41, olcott wrote:If you bothered to understand the recursive emulation non-halting
On 8/7/2025 1:35 PM, Richard Heathfield wrote:
On 07/08/2025 19:27, olcott wrote:Not at all.
<snip>
*I have spent 22 years on this. I do know the proof*
Then you know you're wrong (or you don't know the proof).
The recursive simulation non-halting behavior pattern allowed my >>>>>>> HHH(DD) to correctly compute the mapping *FROM ITS ACTUAL INPUT* >>>>>>> to the non-halting behavior *THAT THIS INPUT SPECIFIES*
That's nice.
Like everyone else you would much rather spend hundreds of hours >>>>>>> disagreeing than five minutes of understanding.
Think about it.
You know from logic that HHH cannot possibly simulate DD's full
behaviour because it isn't until after HHH has finished its work
and returned that DD makes the decision to divert or not divert
into its forever loop.
behavior pattern you would see that DD correctly simulated by HHH
cannot possibly reach its own "if" statement.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
If the halt decider cannot return a decision result to its caller
then it isn't a halt decider.
/Flibble
The outermost instance of HHH always returns a result to its caller
for every input in its domain.
So must any copy of HHH so you fail, epically.
/Flibble
That merely shows that you do not sufficiently understand the *recursive simulation non-halting behavior pattern*
The outermost instance of HHH always returns a
result to its caller for every input in its domain.
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
On 07/08/2025 19:41, olcott wrote:
On 8/7/2025 1:35 PM, Richard Heathfield wrote:
On 07/08/2025 19:27, olcott wrote:
<snip>
*I have spent 22 years on this. I do know the proof*
Then you know you're wrong (or you don't know the proof).
Not at all.
The recursive simulation non-halting behavior pattern
allowed my HHH(DD) to correctly compute the mapping
*FROM ITS ACTUAL INPUT* to the non-halting behavior
*THAT THIS INPUT SPECIFIES*
That's nice.
Like everyone else you would much rather spend hundreds
of hours disagreeing than five minutes of understanding.
Think about it.
You know from logic that HHH cannot possibly simulate DD's full
behaviour because it isn't until after HHH has finished its
work and returned that DD makes the decision to divert or not
divert into its forever loop.
If you bothered to understand the recursive emulation
non-halting behavior pattern you would see that DD
correctly simulated by HHH
Not bothering to pay attention is not a rebuttal.
That merely shows that you do not sufficiently understand
the *recursive simulation non-halting behavior pattern*
On 8/7/2025 4:16 PM, Mr Flibble wrote:
On Thu, 07 Aug 2025 16:11:18 -0500, olcott wrote:
On 8/7/2025 4:05 PM, Mr Flibble wrote:
On Thu, 07 Aug 2025 16:00:17 -0500, olcott wrote:
On 8/7/2025 3:55 PM, Mr Flibble wrote:
On Thu, 07 Aug 2025 15:39:54 -0500, olcott wrote:
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
On 07/08/2025 19:41, olcott wrote:If you bothered to understand the recursive emulation non-halting >>>>>>> behavior pattern you would see that DD correctly simulated by HHH >>>>>>> cannot possibly reach its own "if" statement.
On 8/7/2025 1:35 PM, Richard Heathfield wrote:
On 07/08/2025 19:27, olcott wrote:Not at all.
<snip>
*I have spent 22 years on this. I do know the proof*
Then you know you're wrong (or you don't know the proof).
The recursive simulation non-halting behavior pattern allowed my >>>>>>>>> HHH(DD) to correctly compute the mapping *FROM ITS ACTUAL INPUT* >>>>>>>>> to the non-halting behavior *THAT THIS INPUT SPECIFIES*
That's nice.
Like everyone else you would much rather spend hundreds of hours >>>>>>>>> disagreeing than five minutes of understanding.
Think about it.
You know from logic that HHH cannot possibly simulate DD's full >>>>>>>> behaviour because it isn't until after HHH has finished its work >>>>>>>> and returned that DD makes the decision to divert or not divert >>>>>>>> into its forever loop.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
If the halt decider cannot return a decision result to its caller
then it isn't a halt decider.
/Flibble
The outermost instance of HHH always returns a result to its caller
for every input in its domain.
So must any copy of HHH so you fail, epically.
/Flibble
That merely shows that you do not sufficiently understand the
*recursive simulation non-halting behavior pattern*
I understand it perfectly: if HHH is a halt decider then it must return
a decision result to its caller in finite time ergo both the outer call
to HHH and the inner call to HHH have to be honoured by HHH returning a
decision: the recursion is an ERROR in your design of HHH.
/Flibble
Yes you can imagine that with the vague abstraction of Turing machines.
When you make these ideas 100% concrete by C/x86 you see that is simply
not the case.
When you make these ideas 100%
concrete by C/x86 you see that is simply not the case.
On 8/7/2025 4:53 PM, Richard Heathfield wrote:
On 07/08/2025 22:00, olcott wrote:
The outermost instance of HHH always returns a
result to its caller for every input in its domain.
If you claim that DD is in HHH's domain, it returns the wrong
result.
You must
On 8/7/2025 4:49 PM, Richard Heathfield wrote:
On 07/08/2025 21:39, olcott wrote:
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
On 07/08/2025 19:41, olcott wrote:
On 8/7/2025 1:35 PM, Richard Heathfield wrote:
On 07/08/2025 19:27, olcott wrote:
<snip>
*I have spent 22 years on this. I do know the proof*
Then you know you're wrong (or you don't know the proof).
Not at all.
The recursive simulation non-halting behavior pattern
allowed my HHH(DD) to correctly compute the mapping
*FROM ITS ACTUAL INPUT* to the non-halting behavior
*THAT THIS INPUT SPECIFIES*
That's nice.
Like everyone else you would much rather spend hundreds
of hours disagreeing than five minutes of understanding.
Think about it.
You know from logic that HHH cannot possibly simulate DD's
full behaviour because it isn't until after HHH has finished
its work and returned that DD makes the decision to divert or
not divert into its forever loop.
If you bothered to understand the recursive emulation
The recursive emulation doesn't matter in the slightest.
What matter is what DD actually returns.
HHH can't even begin until DD calls it,
Counter-factual.
int main()
{
HHH(DD);
return 0;
}
On 8/7/2025 5:21 PM, Richard Heathfield wrote:
On 07/08/2025 23:12, olcott wrote:
On 8/7/2025 4:53 PM, Richard Heathfield wrote:
On 07/08/2025 22:00, olcott wrote:
The outermost instance of HHH always returns a
result to its caller for every input in its domain.
If you claim that DD is in HHH's domain, it returns the wrong
result.
You must
Stop right there. You don't get to decide what I must or must
not do.
Yes I do.
If you denigrate my work without examining
my work that is libelous.
On 8/7/2025 4:33 AM, Fred. Zwarts wrote:
Op 07.aug.2025 om 04:59 schreef olcott:
On 8/6/2025 8:37 PM, Richard Damon wrote:Telling incorrect information, by leaving out the actual fact that
On 8/6/25 2:34 PM, olcott wrote:
Simulating Termination Analyzer HHH correctly simulates its input
until:
(a) Detects a non-terminating behavior pattern: abort simulation
and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
Except that YOUR HHH doesn't do that, as the pattern it detects is
part of a Halting Program, so isn't a Non-Halting Pattern.
Of course, since you have admitted that all your claims are based on
LYING that you are actually working on the halting problem, we can't
know what you actaully are meaning, since you start with a
contradiciton.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
The opposite of what it does.
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/
publication/394345150_Halting_Problem_Simulation_Paradox
*Same analysis by ChatGPT*
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok*
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
Which all start with a LIE, as you omit what its ACTUAL actual would
be based on the first two rules, that it can run forever, there is
no certainty that either of the first two conditions will be meet.
Sorry, but all you are doing is proving that you are too stupid to
understand the error, and are now rejoicing that you have found
someone else more stupid than you, even if it never claimed to have
any real intelligence.
Of course, you have admitted that apparently you have spent a lot of
time trying to fashion your question in a way thet gives you the
answer you want, so it isn't a fair test.
How many times have you NOT gotten an answer you wanted?
Of course, you just threw those away.
I have gotten the answer that I wanted at least 15 times
and not gotten it only once. Those 15 times were far too
verbose for anyone to carefully analyze.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
</Input to LLM systems>
also exists:
(c) Pretends to see a non-termination pattern, when it sees only a
finite recursion.
Of course, when feeding them incomplete/incorrect information, they
will produce nonsense.
In all three cases the LLM systems figured out on
their own without prompting that the non-halting
behavior pattern of recursive simulation is reached.
That all three LLM systems figured this out on their
own provides sufficient evidence that I am not a
crackpot with a completely wrong-headed idea.
On 8/7/2025 6:47 PM, Richard Heathfield wrote:
On 08/08/2025 00:42, olcott wrote:
On 8/7/2025 5:21 PM, Richard Heathfield wrote:
On 07/08/2025 23:12, olcott wrote:
On 8/7/2025 4:53 PM, Richard Heathfield wrote:
On 07/08/2025 22:00, olcott wrote:You must
The outermost instance of HHH always returns a
result to its caller for every input in its domain.
If you claim that DD is in HHH's domain, it returns the wrong result. >>>>>
Stop right there. You don't get to decide what I must or must not do.
Yes I do.
No, sir.
If you denigrate my work without examining
my work that is libelous.
See you in court.
That was a cease-and-desist request.
As soon as you understand this:
*recursive simulation non-halting behavior pattern*
you are free to critique my work.
On 8/7/25 9:56 AM, olcott wrote:
On 8/7/2025 4:33 AM, Fred. Zwarts wrote:
Of course, when feeding them incomplete/incorrect information,
they will produce nonsense.
In all three cases the LLM systems figured out on
their own without prompting that the non-halting
behavior pattern of recursive simulation is reached.
Which doesn't mean anything, especially since you gave a
misleading input, since you implied that the decider WILL either
reach the final state or detect a non-halting pattern.
On 8/7/2025 6:47 PM, Richard Heathfield wrote:
On 08/08/2025 00:42, olcott wrote:
On 8/7/2025 5:21 PM, Richard Heathfield wrote:
On 07/08/2025 23:12, olcott wrote:
On 8/7/2025 4:53 PM, Richard Heathfield wrote:
On 07/08/2025 22:00, olcott wrote:
The outermost instance of HHH always returns a
result to its caller for every input in its domain.
If you claim that DD is in HHH's domain, it returns the
wrong result.
You must
Stop right there. You don't get to decide what I must or must
not do.
Yes I do.
No, sir.
If you denigrate my work without examining
my work that is libelous.
See you in court.
That was a cease-and-desist request.
As soon as you understand this:
*recursive simulation non-halting behavior pattern*
you are free to critique my work.
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF* https://www.researchgate.net/publication/394345150_Halting_Problem_Simulation_Paradox
*Same analysis by ChatGPT* https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok* https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-eedd0f09e141
On 8/7/2025 4:28 AM, Fred. Zwarts wrote:
Op 06.aug.2025 om 20:34 schreef olcott:
Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
You forget that there is a third option. In fact that is what happens
here:
(c) Pretends that it sees non-termination pattern, even when it is not
present and returns 0.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
For the cases that HHH returns 0, the correct value that should be
returned is 1.
For the HHH that return 1, the correct value that should be returned
is 0.
*This is the big mistake of all of the halting problem proofs*
When HHH reports on the behavior specified by its correct
emulation of N steps of its input the non-halting behavior
pattern of recursive simulation is reached.
HHH(DDD) only gets the wrong answer when one expects that
HHH must report on the behavior of the non-input direct
execution of DDD().
On 8/7/2025 5:18 PM, Richard Heathfield wrote:
On 07/08/2025 23:09, olcott wrote:
On 8/7/2025 4:49 PM, Richard Heathfield wrote:
On 07/08/2025 21:39, olcott wrote:
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
On 07/08/2025 19:41, olcott wrote:
On 8/7/2025 1:35 PM, Richard Heathfield wrote:
On 07/08/2025 19:27, olcott wrote:
<snip>
*I have spent 22 years on this. I do know the proof*
Then you know you're wrong (or you don't know the proof).
Not at all.
The recursive simulation non-halting behavior pattern
allowed my HHH(DD) to correctly compute the mapping
*FROM ITS ACTUAL INPUT* to the non-halting behavior
*THAT THIS INPUT SPECIFIES*
That's nice.
Like everyone else you would much rather spend hundreds
of hours disagreeing than five minutes of understanding.
Think about it.
You know from logic that HHH cannot possibly simulate DD's full
behaviour because it isn't until after HHH has finished its work
and returned that DD makes the decision to divert or not divert
into its forever loop.
If you bothered to understand the recursive emulation
The recursive emulation doesn't matter in the slightest.
What matter is what DD actually returns.
HHH can't even begin until DD calls it,
Counter-factual.
int main()
{
HHH(DD);
return 0;
}
That's the first sensible response I've seen from you - ever, I think.
Unfortunately for you, it fails to answer the question of whether DD
halts:
int main()
{
DD();
return 0;
}
Until you first understand this:
*recursive simulation non-halting behavior pattern*
You will not have the basis to understand anything
that I say.
*recursive simulation non-halting behavior pattern* https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
Is all in the above one page quick read.
You can spend 10,000 hours avoiding spending five minutes
yet I will remain utterly relentless on this point.
On 8/7/2025 4:33 AM, Fred. Zwarts wrote:
Op 07.aug.2025 om 04:59 schreef olcott:
On 8/6/2025 8:37 PM, Richard Damon wrote:Telling incorrect information, by leaving out the actual fact that
On 8/6/25 2:34 PM, olcott wrote:
Simulating Termination Analyzer HHH correctly simulates its input
until:
(a) Detects a non-terminating behavior pattern: abort simulation
and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
Except that YOUR HHH doesn't do that, as the pattern it detects is
part of a Halting Program, so isn't a Non-Halting Pattern.
Of course, since you have admitted that all your claims are based on
LYING that you are actually working on the halting problem, we can't
know what you actaully are meaning, since you start with a
contradiciton.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
The opposite of what it does.
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/
publication/394345150_Halting_Problem_Simulation_Paradox
*Same analysis by ChatGPT*
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok*
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
Which all start with a LIE, as you omit what its ACTUAL actual would
be based on the first two rules, that it can run forever, there is
no certainty that either of the first two conditions will be meet.
Sorry, but all you are doing is proving that you are too stupid to
understand the error, and are now rejoicing that you have found
someone else more stupid than you, even if it never claimed to have
any real intelligence.
Of course, you have admitted that apparently you have spent a lot of
time trying to fashion your question in a way thet gives you the
answer you want, so it isn't a fair test.
How many times have you NOT gotten an answer you wanted?
Of course, you just threw those away.
I have gotten the answer that I wanted at least 15 times
and not gotten it only once. Those 15 times were far too
verbose for anyone to carefully analyze.
<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
</Input to LLM systems>
also exists:
(c) Pretends to see a non-termination pattern, when it sees only a
finite recursion.
Of course, when feeding them incomplete/incorrect information, they
will produce nonsense.
In all three cases the LLM systems figured out on
their own without prompting that the non-halting
behavior pattern of recursive simulation is reached.
That all three LLM systems figured this out on their
own provides sufficient evidence that I am not a
crackpot with a completely wrong-headed idea.
You got a different version 5.0 that did not bother to
do an execution trace of DD correctly simulated by HHH.
On 8/8/2025 1:23 PM, Richard Heathfield wrote:
On 08/08/2025 15:58, olcott wrote:
You got a different version 5.0 that did not bother to
do an execution trace of DD correctly simulated by HHH.
So you're saying you don't trust AI to get it right?
Damn straight. Neither do I.
Sometimes AI does not consider all of the relevant details.
By simply prompting it to examine these details and it
almost always gets the correct answer.
On 8/8/2025 1:36 AM, Richard Heathfield wrote:
On 08/08/2025 01:53, Richard Damon wrote:
On 8/7/25 9:56 AM, olcott wrote:
On 8/7/2025 4:33 AM, Fred. Zwarts wrote:
<snip>
Of course, when feeding them incomplete/incorrect information, they
will produce nonsense.
In all three cases the LLM systems figured out on
their own without prompting that the non-halting
behavior pattern of recursive simulation is reached.
Which doesn't mean anything, especially since you gave a misleading
input, since you implied that the decider WILL either reach the final
state or detect a non-halting pattern.
Interestingly, when I presented Olcott's case (verbatim) to ChatGPT
but preceded it with the words "I am testing the assumption that",
ChatGPT figured out all by itself that Olcott is talking bollocks.
You got a different version 5.0 that did not bother to
do an execution trace of DD correctly simulated by HHH.
Do an execution trace of DD correctly simulated by
HHH to answer this question:
What value should HHH(DD) correctly return?
https://chatgpt.com/share/68960fbc-b380-8011-b554-090a2eefe4e7
✅ Conclusion:
HHH should detect that simulating DD never reaches the
return statement and just loops in simulation forever.
Therefore:
HHH(DD) returns 0
6. Final Answer HHH(DD) should return 0.
On 08/08/2025 20:22, olcott wrote:
On 8/8/2025 1:23 PM, Richard Heathfield wrote:
On 08/08/2025 15:58, olcott wrote:
You got a different version 5.0 that did not bother to
do an execution trace of DD correctly simulated by HHH.
So you're saying you don't trust AI to get it right?
Damn straight. Neither do I.
Sometimes AI does not consider all of the relevant details.
That's why I told it that I wanted to check your assumption.
By simply prompting it to examine these details and it
almost always gets the correct answer.
Indeed. It concluded that your assumption was false.
On 8/8/2025 2:31 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/
publication/394345150_Halting_Problem_Simulation_Paradox
*Same analysis by ChatGPT*
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok*
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
Quite obviously the correct value HHH(DD) should return is !HHH(DD).
According to the above definition of "int HHH(ptr P);"
!HHH(DD) is the 0 return value.
On 8/8/2025 1:25 AM, Richard Heathfield wrote:
On 08/08/2025 01:33, olcott wrote:
On 8/7/2025 6:47 PM, Richard Heathfield wrote:
On 08/08/2025 00:42, olcott wrote:
On 8/7/2025 5:21 PM, Richard Heathfield wrote:
On 07/08/2025 23:12, olcott wrote:
On 8/7/2025 4:53 PM, Richard Heathfield wrote:
On 07/08/2025 22:00, olcott wrote:
The outermost instance of HHH always returns a
result to its caller for every input in its domain.
If you claim that DD is in HHH's domain, it returns the wrong
result.
You must
Stop right there. You don't get to decide what I must or must not do. >>>>>>
Yes I do.
No, sir.
If you denigrate my work without examining
my work that is libelous.
See you in court.
That was a cease-and-desist request.
No, it was a Usenet article. If my solicitor receives a cease and
desist letter from your solicitor, I'll have him respond in writing.
All that I am asking for is a fair review of my actual
work. You are doing much better at that now.
As soon as you understand this:
*recursive simulation non-halting behavior pattern*
you are free to critique my work.
I'm free to opine that your "work" fails to demonstrate the claim you
make for it.
Not on the basis of failing to understand a key element
of my work.
Specifically, your claim that:
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
I have already demonstrated ad nauseam that the claim is false. So
have several other people.
It is a verified fact that DD correctly simulated by HHH
cannot possibly reach its own simulated "return" statement
final halt state.
It is a verified fact that HHH(DD) correctly detects this.
This C/C++ system has been fully operational for three years. https://github.com/plolcott/x86utm
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
Figured out the *recursive simulation non-halting behavior pattern*
entirely on its own.
Claude AI and explains every detail of why HHH(DD)==0
is correct. It is only a single page of text that is very
easy to understand by anyone that is good at C.
On 8/8/2025 3:08 AM, Fred. Zwarts wrote:
Op 08.aug.2025 om 01:40 schreef olcott:
On 8/7/2025 5:18 PM, Richard Heathfield wrote:
On 07/08/2025 23:09, olcott wrote:
On 8/7/2025 4:49 PM, Richard Heathfield wrote:
On 07/08/2025 21:39, olcott wrote:
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
On 07/08/2025 19:41, olcott wrote:
On 8/7/2025 1:35 PM, Richard Heathfield wrote:
On 07/08/2025 19:27, olcott wrote:
<snip>
*I have spent 22 years on this. I do know the proof*
Then you know you're wrong (or you don't know the proof).
Not at all.
The recursive simulation non-halting behavior pattern
allowed my HHH(DD) to correctly compute the mapping
*FROM ITS ACTUAL INPUT* to the non-halting behavior
*THAT THIS INPUT SPECIFIES*
That's nice.
Like everyone else you would much rather spend hundreds
of hours disagreeing than five minutes of understanding.
Think about it.
You know from logic that HHH cannot possibly simulate DD's full >>>>>>>> behaviour because it isn't until after HHH has finished its work >>>>>>>> and returned that DD makes the decision to divert or not divert >>>>>>>> into its forever loop.
If you bothered to understand the recursive emulation
The recursive emulation doesn't matter in the slightest.
What matter is what DD actually returns.
HHH can't even begin until DD calls it,
Counter-factual.
int main()
{
HHH(DD);
return 0;
}
That's the first sensible response I've seen from you - ever, I think. >>>>
Unfortunately for you, it fails to answer the question of whether DD
halts:
int main()
{
DD();
return 0;
}
Until you first understand this:
*recursive simulation non-halting behavior pattern*
You will not have the basis to understand anything
that I say.
*recursive simulation non-halting behavior pattern*
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
Is all in the above one page quick read.
You can spend 10,000 hours avoiding spending five minutes
yet I will remain utterly relentless on this point.
The first thing you need to understand is that a finite recursion is
not evidence for non-termination behaviour.
That a small sample of DD correctly simulated by HHH
meets the:
*recursive simulation non-halting behavior pattern*
is understood by three LLM systems.
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
They figured out the
*recursive simulation non-halting behavior pattern*
on their own without prompting.
Ignoring the conditional branch instructions in these recursions, make
it even less plausible that the non-termination behaviour is detected
correctly.
Unless you understand that the condition of these
conditional branches is not met by any instance
of HHH correctly emulated by the outermost directly
executed HHH.
When other simulators show that the exact same input specifies a
terminating program, the proof is complete that the detection of non-
termination behaviour is a bug in the program.
I use the concrete C programming language so that key
details are not merely abstracted away by false assumptions.
When I do this then false assumptions are proven to be
counter-factual.
It may be very difficult to understand, yet the behavior
of non-inputs does not count. Simulating termination
analyzers are only accountable for the behavior that their
inputs specify.
Correct simulation is a correct measure of this behavior.
Correct simulation and direct execution only vary when
an input calls its own simulating termination analyzer.
In the case it is the input that rules and non-inputs are
irrelevant.
*These two facts can be verified*
DD correctly simulated by HHH cannot possibly reach
its own simulated "return" statement final halt state.
HHH(DD) correctly detects and reports this.
Here is the complete C/C++ codebase:
https://github.com/plolcott/x86utm
On 8/8/2025 3:33 PM, Richard Heathfield wrote:
On 08/08/2025 20:22, olcott wrote:
On 8/8/2025 1:23 PM, Richard Heathfield wrote:
On 08/08/2025 15:58, olcott wrote:
You got a different version 5.0 that did not bother to
do an execution trace of DD correctly simulated by HHH.
So you're saying you don't trust AI to get it right?
Damn straight. Neither do I.
Sometimes AI does not consider all of the relevant details.
That's why I told it that I wanted to check your assumption.
By simply prompting it to examine these details and it
almost always gets the correct answer.
Indeed. It concluded that your assumption was false.
It concluded that the assumption is false entirely
on the basis of guessing the behavior of DD instead
of measuring this behavior by an execution trace.
On 8/8/2025 3:33 PM, Richard Heathfield wrote:
On 08/08/2025 20:22, olcott wrote:
On 8/8/2025 1:23 PM, Richard Heathfield wrote:
On 08/08/2025 15:58, olcott wrote:
You got a different version 5.0 that did not bother to
do an execution trace of DD correctly simulated by HHH.
So you're saying you don't trust AI to get it right?
Damn straight. Neither do I.
Sometimes AI does not consider all of the relevant details.
That's why I told it that I wanted to check your assumption.
By simply prompting it to examine these details and it
almost always gets the correct answer.
Indeed. It concluded that your assumption was false.
It concluded that the assumption is false entirely
on the basis of guessing the behavior of DD instead
of measuring this behavior by an execution trace.
When I told it not to guess, then it agreed with me.
On 8/8/2025 5:58 PM, Richard Heathfield wrote:
Brute force may not be elegant, but it is not guessing.
If HHH claims DD halts, DD loops.
If HHH claims DD loops, DD halts.
Either way, HHH loses.
Your version did not notice that the "if" statement
is unreachable
On 8/8/2025 5:58 PM, Richard Heathfield wrote:
On 08/08/2025 23:19, olcott wrote:
On 8/8/2025 3:33 PM, Richard Heathfield wrote:
On 08/08/2025 20:22, olcott wrote:
On 8/8/2025 1:23 PM, Richard Heathfield wrote:
On 08/08/2025 15:58, olcott wrote:
You got a different version 5.0 that did not bother to
do an execution trace of DD correctly simulated by HHH.
So you're saying you don't trust AI to get it right?
Damn straight. Neither do I.
Sometimes AI does not consider all of the relevant details.
That's why I told it that I wanted to check your assumption.
By simply prompting it to examine these details and it
almost always gets the correct answer.
Indeed. It concluded that your assumption was false.
It concluded that the assumption is false entirely
on the basis of guessing the behavior of DD instead
of measuring this behavior by an execution trace.
Clearly you didn't read the transcript.
It enumerated both possibilities for HHH's return values and showed
that in each case DD exhibited the opposite behaviour to that claimed
for DD by HHH.
Brute force may not be elegant, but it is not guessing.
If HHH claims DD halts, DD loops.
If HHH claims DD loops, DD halts.
Either way, HHH loses.
Your version did not notice that the "if" statement
is unreachable because it guessed the behavior of
DD simulated by HHH instead of performing an execution
trace.
Many people have expressed that they think 5.0 is a
downgrade.
On 8/8/2025 6:21 PM, Richard Heathfield wrote:
On 09/08/2025 00:07, olcott wrote:
On 8/8/2025 5:58 PM, Richard Heathfield wrote:
<snip>
Brute force may not be elegant, but it is not guessing.
If HHH claims DD halts, DD loops.
If HHH claims DD loops, DD halts.
Either way, HHH loses.
Your version did not notice that the "if" statement
is unreachable
But that is only the case if HHH fails to return.
*it is absolutely the case no matter what*
On 8/8/2025 11:24 PM, Richard Heathfield wrote:
On 09/08/2025 05:19, olcott wrote:
On 8/8/2025 6:21 PM, Richard Heathfield wrote:
On 09/08/2025 00:07, olcott wrote:
On 8/8/2025 5:58 PM, Richard Heathfield wrote:
<snip>
Brute force may not be elegant, but it is not guessing.
If HHH claims DD halts, DD loops.
If HHH claims DD loops, DD halts.
Either way, HHH loses.
Your version did not notice that the "if" statement
is unreachable
But that is only the case if HHH fails to return.
*it is absolutely the case no matter what*
Show me why, when HHH(DD) returns 0, the "if" is unreachable:
The trickier part is why the "if" remains
unreachable even if HHH emulates a billon
instructions of DD.
On 8/8/2025 11:24 PM, Richard Heathfield wrote:
On 09/08/2025 05:19, olcott wrote:
On 8/8/2025 6:21 PM, Richard Heathfield wrote:
On 09/08/2025 00:07, olcott wrote:
On 8/8/2025 5:58 PM, Richard Heathfield wrote:
<snip>
Brute force may not be elegant, but it is not guessing.
If HHH claims DD halts, DD loops.
If HHH claims DD loops, DD halts.
Either way, HHH loses.
Your version did not notice that the "if" statement
is unreachable
But that is only the case if HHH fails to return.
*it is absolutely the case no matter what*
Show me why, when HHH(DD) returns 0, the "if" is unreachable:
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
DD correctly emulated by HHH cycles through its first
five instructions until aborted.
On 8/8/2025 3:08 AM, Fred. Zwarts wrote:
Op 08.aug.2025 om 01:40 schreef olcott:
On 8/7/2025 5:18 PM, Richard Heathfield wrote:
On 07/08/2025 23:09, olcott wrote:
On 8/7/2025 4:49 PM, Richard Heathfield wrote:
On 07/08/2025 21:39, olcott wrote:
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
On 07/08/2025 19:41, olcott wrote:
On 8/7/2025 1:35 PM, Richard Heathfield wrote:
On 07/08/2025 19:27, olcott wrote:
<snip>
*I have spent 22 years on this. I do know the proof*
Then you know you're wrong (or you don't know the proof).
Not at all.
The recursive simulation non-halting behavior pattern
allowed my HHH(DD) to correctly compute the mapping
*FROM ITS ACTUAL INPUT* to the non-halting behavior
*THAT THIS INPUT SPECIFIES*
That's nice.
Like everyone else you would much rather spend hundreds
of hours disagreeing than five minutes of understanding.
Think about it.
You know from logic that HHH cannot possibly simulate DD's full >>>>>>>> behaviour because it isn't until after HHH has finished its work >>>>>>>> and returned that DD makes the decision to divert or not divert >>>>>>>> into its forever loop.
If you bothered to understand the recursive emulation
The recursive emulation doesn't matter in the slightest.
What matter is what DD actually returns.
HHH can't even begin until DD calls it,
Counter-factual.
int main()
{
HHH(DD);
return 0;
}
That's the first sensible response I've seen from you - ever, I think. >>>>
Unfortunately for you, it fails to answer the question of whether DD
halts:
int main()
{
DD();
return 0;
}
Until you first understand this:
*recursive simulation non-halting behavior pattern*
You will not have the basis to understand anything
that I say.
*recursive simulation non-halting behavior pattern*
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
Is all in the above one page quick read.
You can spend 10,000 hours avoiding spending five minutes
yet I will remain utterly relentless on this point.
The first thing you need to understand is that a finite recursion is
not evidence for non-termination behaviour.
That a small sample of DD correctly simulated by HHH
meets the:
*recursive simulation non-halting behavior pattern*
is understood by three LLM systems.
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
They figured out the
*recursive simulation non-halting behavior pattern*
on their own without prompting.
Ignoring the conditional branch instructions in these recursions, make
it even less plausible that the non-termination behaviour is detected
correctly.
Unless you understand that the condition of these
conditional branches is not met by any instance
of HHH correctly emulated by the outermost directly
executed HHH.
When other simulators show that the exact same input specifies a
terminating program, the proof is complete that the detection of non-
termination behaviour is a bug in the program.
I use the concrete C programming language so that key
details are not merely abstracted away by false assumptions.
When I do this then false assumptions are proven to be
counter-factual.
It may be very difficult to understand, yet the behavior
of non-inputs does not count. Simulating termination
analyzers are only accountable for the behavior that their
inputs specify.
Correct simulation is a correct measure of this behavior.
Correct simulation and direct execution only vary when
an input calls its own simulating termination analyzer.
In the case it is the input that rules and non-inputs are
irrelevant.
*These two facts can be verified*
DD correctly simulated by HHH cannot possibly reach
its own simulated "return" statement final halt state.
HHH(DD) correctly detects and reports this.
Here is the complete C/C++ codebase:
https://github.com/plolcott/x86utm
On 8/8/2025 11:24 PM, Richard Heathfield wrote:
On 09/08/2025 05:19, olcott wrote:
On 8/8/2025 6:21 PM, Richard Heathfield wrote:
On 09/08/2025 00:07, olcott wrote:
On 8/8/2025 5:58 PM, Richard Heathfield wrote:
<snip>
Brute force may not be elegant, but it is not guessing.
If HHH claims DD halts, DD loops.
If HHH claims DD loops, DD halts.
Either way, HHH loses.
Your version did not notice that the "if" statement
is unreachable
But that is only the case if HHH fails to return.
*it is absolutely the case no matter what*
Show me why, when HHH(DD) returns 0, the "if" is unreachable:
The trickier part is why the "if" remains
unreachable even if HHH emulates a billon
instructions of DD.
HHH(DD) gives DD and everything that DD calls its own
heart beat be simulating one instruction of one machine.
If HHH stops simulating then everything besides HHH
immediately dies.
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
On 8/8/2025 11:24 PM, Richard Heathfield wrote:
On 09/08/2025 05:19, olcott wrote:
On 8/8/2025 6:21 PM, Richard Heathfield wrote:
On 09/08/2025 00:07, olcott wrote:
On 8/8/2025 5:58 PM, Richard Heathfield wrote:
<snip>
Brute force may not be elegant, but it is not guessing.
If HHH claims DD halts, DD loops.
If HHH claims DD loops, DD halts.
Either way, HHH loses.
Your version did not notice that the "if" statement
is unreachable
But that is only the case if HHH fails to return.
*it is absolutely the case no matter what*
Show me why, when HHH(DD) returns 0, the "if" is unreachable:
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
DD correctly emulated by HHH cycles through its first
five instructions until aborted.
_DD()
[00002162] 55 push ebp
[00002163] 8bec mov ebp,esp
[00002165] 51 push ecx
[00002166] 6862210000 push 00002162 // push DD
[0000216b] e862f4ffff call 000015d2 // call HHH
[00002170] 83c404 add esp,+04
[00002173] 8945fc mov [ebp-04],eax
[00002176] 837dfc00 cmp dword [ebp-04],+00
[0000217a] 7402 jz 0000217e
[0000217c] ebfe jmp 0000217c
[0000217e] 8b45fc mov eax,[ebp-04]
[00002181] 8be5 mov esp,ebp
[00002183] 5d pop ebp
[00002184] c3 ret
Size in bytes:(0035) [00002184]
On 8/8/2025 6:21 PM, Richard Heathfield wrote:
On 09/08/2025 00:07, olcott wrote:
On 8/8/2025 5:58 PM, Richard Heathfield wrote:
<snip>
Brute force may not be elegant, but it is not guessing.
If HHH claims DD halts, DD loops.
If HHH claims DD loops, DD halts.
Either way, HHH loses.
Your version did not notice that the "if" statement
is unreachable
But that is only the case if HHH fails to return.
*it is absolutely the case no matter what*
Is it your argument that HHH is broken? That would clear up a lot.
DD emulated by HHH according to the semantics of the
x86 language cannot possibly reach its own "ret"
instruction final halt state, this by itself proves
that HHH(DD)==0 is correct when HHH is reporting
on the behavior that its input actually specifies.
A termination analyzer is required to report on the
actual behavior that its input actually specifies
even when this input calls its termination analyzer
in recursive emulation.
Its kind of goofy that people think a termination
analyzer is not supposed to report on the actual
behavior that its input actually specifies.
On 8/9/2025 1:01 AM, Richard Heathfield wrote:
On 09/08/2025 05:54, olcott wrote:
On 8/8/2025 11:24 PM, Richard Heathfield wrote:
On 09/08/2025 05:19, olcott wrote:
On 8/8/2025 6:21 PM, Richard Heathfield wrote:
On 09/08/2025 00:07, olcott wrote:
On 8/8/2025 5:58 PM, Richard Heathfield wrote:
<snip>
Brute force may not be elegant, but it is not guessing.
If HHH claims DD halts, DD loops.
If HHH claims DD loops, DD halts.
Either way, HHH loses.
Your version did not notice that the "if" statement
is unreachable
But that is only the case if HHH fails to return.
*it is absolutely the case no matter what*
Show me why, when HHH(DD) returns 0, the "if" is unreachable:
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
DD correctly emulated by HHH cycles through its first
five instructions until aborted.
So HHH never returns to its caller, and therefore fails to report.
When you claim that the if is not reached, you also make the
equivalent claim that HHH doesn't return.
u32 Needs_To_Be_Aborted_Trace_HH
On 8/9/2025 2:05 AM, Fred. Zwarts wrote:
Op 08.aug.2025 om 18:00 schreef olcott:>><Complete Input>
That a small sample of DD correctly simulated by HHH
meets the:
*recursive simulation non-halting behavior pattern*
is understood by three LLM systems.
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
They figured out the
*recursive simulation non-halting behavior pattern*
on their own without prompting.
But even a first year students sees that they were fed with incorrect
assumption.
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
</Complete Input>
No incorrect assumptions in the above as evidenced by
the fact that all three LLM systems were able to figure
out the *recursive simulation non-halting behavior pattern*
all on their own.
On 8/9/2025 2:05 AM, Fred. Zwarts wrote:
Op 08.aug.2025 om 18:00 schreef olcott:>><Complete Input>
That a small sample of DD correctly simulated by HHH
meets the:
*recursive simulation non-halting behavior pattern*
is understood by three LLM systems.
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21-
eedd0f09e141
They figured out the
*recursive simulation non-halting behavior pattern*
on their own without prompting.
But even a first year students sees that they were fed with incorrect
assumption.
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and
return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
</Complete Input>
No incorrect assumptions in the above as evidenced by
the fact that all three LLM systems were able to figure
out the *recursive simulation non-halting behavior pattern*
all on their own.
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt decider.
If it returns 'no' it is not a halt decider. If it returns anyting else
it is not a halt decider. If it does not return it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
On 07/08/2025 17:50, olcott wrote:
On 8/7/2025 11:24 AM, Richard Heathfield wrote:
<snip>
Let's consider all possible cases. There are only two cases --- HHH
should report either a halt or a forever loop.
CASE ONE: DD NEVER RETURNS
--------------------------
If DD never halts (doesn't return), HHH must return 0, so
if(Halt_Status) will fail, and DD will return - a contradiction, so our
assumption is false.
*I am so happy that you are going over this with me, thanks*
Next step: learn to read for comprehension.
On 8/7/2025 4:28 AM, Fred. Zwarts wrote:
Op 06.aug.2025 om 20:34 schreef olcott:
Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
You forget that there is a third option. In fact that is what happens here: >>
(c) Pretends that it sees non-termination pattern, even when it is not
present and returns 0.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
For the cases that HHH returns 0, the correct value that should be
returned is 1.
For the HHH that return 1, the correct value that should be returned is 0.
*This is the big mistake of all of the halting problem proofs*
When HHH reports on the behavior specified by its correct
emulation of N steps of its input the non-halting behavior
pattern of recursive simulation is reached.
On 8/7/2025 4:05 PM, joes wrote:
Am Thu, 07 Aug 2025 16:00:17 -0500 schrieb olcott:
On 8/7/2025 3:55 PM, Mr Flibble wrote:That's what he said.
On Thu, 07 Aug 2025 15:39:54 -0500, olcott wrote:
On 8/7/2025 3:14 PM, Richard Heathfield wrote:
You know from logic that HHH cannot possibly simulate DD's fullIf you bothered to understand the recursive emulation non-halting
behaviour because it isn't until after HHH has finished its work and >>>>>> returned that DD makes the decision to divert or not divert into its >>>>>> forever loop.
behavior pattern you would see that DD correctly simulated by HHH
cannot possibly reach its own "if" statement.
That is not a full understanding.
On 8/8/2025 2:31 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
https://claude.ai/share/da9e56ba-f4e9-45ee-9f2c-dc5ffe10f00c
*Same analysis as a one page PDF*
https://www.researchgate.net/
publication/394345150_Halting_Problem_Simulation_Paradox
*Same analysis by ChatGPT*
https://chatgpt.com/share/68939ee5-e2f8-8011-837d-438fe8e98b9c
*Same analysis by Grok*
https://grok.com/share/c2hhcmQtMg%3D%3D_810120bb-5ab5-4bf8-af21- eedd0f09e141
Quite obviously the correct value HHH(DD) should return is !HHH(DD).
According to the above definition of "int HHH(ptr P);"
!HHH(DD) is the 0 return value.
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
Simulating Termination Analyzer HHH correctly simulates its input
until:
(a) Detects a non-terminating behavior pattern: abort simulation
and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt
decider.
If it returns 'no' it is not a halt decider. If it returns anyting else >>>> it is not a halt decider. If it does not return it is not a halt
decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:HHH(DD)==0 means that the behavior specified by the
Simulating Termination Analyzer HHH correctly simulates its input until: >>>>> (a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1. >>>>>
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt decider. >>>> If it returns 'no' it is not a halt decider. If it returns anyting else >>>> it is not a halt decider. If it does not return it is not a halt decider. >>>
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
On 8/10/25 11:30 AM, olcott wrote:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:HHH(DD)==0 means that the behavior specified by the
Simulating Termination Analyzer HHH correctly simulates its input until: >>>>>> (a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1. >>>>>>
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt decider. >>>>> If it returns 'no' it is not a halt decider. If it returns anyting else >>>>> it is not a halt decider. If it does not return it is not a halt decider. >>>>
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
Sure it does, it just might take a googolplex^(googolplex^googolplex) steps.
Actually, it seems to be about 50-100 x N, since that seems to be about
how many steps it task to simulate one instruction, so that is what it
takes to do one more level of simulation.
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
Simulating Termination Analyzer HHH correctly simulates its input >>>>>>> until:
(a) Detects a non-terminating behavior pattern: abort simulation >>>>>>> and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt
decider.
If it returns 'no' it is not a halt decider. If it returns anyting >>>>>> else
it is not a halt decider. If it does not return it is not a halt
decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
If N = googolplex ^ googolplex then HHH never simulated that many steps.
Within the premise that HHH did simulate that many
steps DD still did not reach its own simulated "return"
statement final halt state.
*Machine M contains simulating halt decider H*
M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.qy
M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.qn
*Repeats until aborted proving non-halting*
(a) M copies its input ⟨M⟩
(b) M invokes M.H ⟨M⟩ ⟨M⟩
(c) M.H simulates ⟨M⟩ ⟨M⟩
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern: abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement: return 1. >>>>>>>
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt decider. >>>>>> If it returns 'no' it is not a halt decider. If it returns anyting else >>>>>> it is not a halt decider. If it does not return it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
If N = googolplex ^ googolplex then HHH never simulated that many steps.
Within the premise that HHH did simulate that many
steps DD still did not reach its own simulated "return"
statement final halt state.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (1 / 15) |
| Uptime: | 159:15:48 |
| Calls: | 10,385 |
| Calls today: | 2 |
| Files: | 14,056 |
| Messages: | 6,416,491 |