If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
What value should HHH(DD) correctly return?
On 8/27/2025 12:58 PM, Richard Heathfield wrote:
On 27/08/2025 18:38, olcott wrote:
What value should HHH(DD) correctly return?
You say 0, right? I'll buy that.
All halt deciders only report on the behavior
that their input finite string specifies and
don't give a rat's ass about any damn thing
else such as that DD() halts.
On 8/27/2025 1:35 PM, Richard Heathfield wrote:
On 27/08/2025 19:15, olcott wrote:
On 8/27/2025 12:58 PM, Richard Heathfield wrote:
On 27/08/2025 18:38, olcott wrote:
<snip>
What value should HHH(DD) correctly return?
You say 0, right? I'll buy that.
All halt deciders only report on the behavior
that their input finite string specifies and
don't give a rat's ass about any damn thing
else such as that DD() halts.
A string is a contiguous sequence of characters terminated by
and including the first null character.
When we make sure to keep the correspondence to
Turing machines
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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/18/2025 6:05 PM, Richard Heathfield wrote:
It is an easily verified fact, as you love to say,
that if DD calls HHH (as it does) and HHH calls DD
(as, through simulation, it effectively does) that
HHH(DD) can never halt naturally, so it will have
to abort the recursion and report its result as 0
- didn't halt.
On 8/27/2025 1:35 PM, Richard Heathfield wrote:
On 27/08/2025 19:15, olcott wrote:
On 8/27/2025 12:58 PM, Richard Heathfield wrote:
On 27/08/2025 18:38, olcott wrote:
<snip>
What value should HHH(DD) correctly return?
You say 0, right? I'll buy that.
All halt deciders only report on the behavior
that their input finite string specifies and
don't give a rat's ass about any damn thing
else such as that DD() halts.
A string is a contiguous sequence of characters terminated by and
including the first null character.
When we make sure to keep the correspondence to
Turing machines then an input is any finite string
of characters.
HHH doesn't get a string. It gets a function pointer. If it can't
decide the halting status of the function pointed to by that pointer,
it doesn't do the job.
A pointer to a finite string of characters.
Some differences are of no consequence thus
don't really make a difference.
And it can't, so it doesn't.
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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/18/2025 6:05 PM, Richard Heathfield wrote:
It is an easily verified fact, as you love to say,
that if DD calls HHH (as it does) and HHH calls DD
(as, through simulation, it effectively does) that
HHH(DD) can never halt naturally, so it will have
to abort the recursion and report its result as 0
- didn't halt.
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
On 8/28/2025 2:18 AM, Mikko wrote:
On 2025-08-27 17:38:28 +0000, olcott said:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
No, the relationship is essentially different.
It is different yet essentially the same in that it
produces the exact same non-halting behavior pattern.
On 8/28/2025 9:56 AM, Richard Heathfield wrote:
On 28/08/2025 15:29, olcott wrote:
On 8/28/2025 2:18 AM, Mikko wrote:
On 2025-08-27 17:38:28 +0000, olcott said:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
No, the relationship is essentially different.
It is different yet essentially the same in that it
produces the exact same non-halting behavior pattern.
Is this the simulated non-halting behaviour where the
simulation halts?
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
OutputString("I never get here you dumb bunny!\n");
return;
}
These simulations halt too you dumb bunny!
On 8/28/2025 2:18 AM, Mikko wrote:
On 2025-08-27 17:38:28 +0000, olcott said:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
No, the relationship is essentially different.
It is different yet essentially the same in that it
produces the exact same non-halting behavior pattern.
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
int factorial_caller()
{
factorial(5);
}
On 8/29/2025 2:03 AM, Mikko wrote:
On 2025-08-28 14:29:44 +0000, olcott said:
On 8/28/2025 2:18 AM, Mikko wrote:
On 2025-08-27 17:38:28 +0000, olcott said:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
No, the relationship is essentially different.
It is different yet essentially the same in that it
produces the exact same non-halting behavior pattern.
If HHH calls DD it cannot observe any details of the behaviour of DD.
HHH creates a proxy for its own behavior and then observes that.
int Pseudo_HHH(ptr x)
{
x();
return 1;
}
int DD()
{
int Halt_Status = Pseudo_HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD)==0.
In this case HHH has to be as smart as and LLM
that knows that it can substitute recursion
for simulation and still have the same behavior pattern.
Then it simulates this simpler case.
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
On 8/30/2025 2:57 AM, Mikko wrote:
On 2025-08-29 13:45:01 +0000, olcott said:
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
No, you did not. You did not even claim it without a proof as you
yousally you, You said nothing.
When I proved that HHH does get the correct
answer on some input then I have proved that
simulating termination analyzers do exist.
On 8/30/2025 3:35 AM, Fred. Zwarts wrote:
Op 29.aug.2025 om 15:45 schreef olcott:
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
Counter factual. You never even tried to show me wrong.
When I prove that you are wrong and you cannot
understand this proof that does not mean that
I did not prove that you are wrong.
That HHH does get the correct answer on some
inputs proves that the notion of simulating
termination analyzer is correct.
You injected your prejudice that HHH aborts because it detects a non-
termination behaviour pattern, when in fact HHH prematurely aborts due
to a bug which makes that it does not see the difference between a
finite recursion and a non-termination behaviour pattern. It aborts
when it sees only a finite recursion and, without evidence, assumes
that it is a non-termination pattern.
Conclusion based on such incorrect assumptions have no value.
That HHH does get the correct answer on some
inputs proves that the notion of simulating
termination analyzer is correct.
On 8/30/2025 2:57 AM, Mikko wrote:
On 2025-08-29 13:45:01 +0000, olcott said:
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
No, you did not. You did not even claim it without a proof as you
yousally you, You said nothing.
When I proved that HHH does get the correct
answer on some input then I have proved that
simulating termination analyzers do exist.
On 8/30/2025 3:35 AM, Fred. Zwarts wrote:
Op 29.aug.2025 om 15:45 schreef olcott:
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
Counter factual. You never even tried to show me wrong.
When I prove that you are wrong and you cannot
understand this proof that does not mean that
I did not prove that you are wrong.
On 8/30/2025 3:01 AM, Mikko wrote:
On 2025-08-29 14:14:51 +0000, olcott said:
On 8/29/2025 2:03 AM, Mikko wrote:
On 2025-08-28 14:29:44 +0000, olcott said:
On 8/28/2025 2:18 AM, Mikko wrote:
On 2025-08-27 17:38:28 +0000, olcott said:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
No, the relationship is essentially different.
It is different yet essentially the same in that it
produces the exact same non-halting behavior pattern.
If HHH calls DD it cannot observe any details of the behaviour of DD.
HHH creates a proxy for its own behavior and then observes that.
int Pseudo_HHH(ptr x)
{
x();
return 1;
}
int DD()
{
int Halt_Status = Pseudo_HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
HHH(DD)==0.
In this case HHH has to be as smart as and LLM
that knows that it can substitute recursion
for simulation and still have the same behavior pattern.
Then it simulates this simpler case.
And gets a wrong result, apparently because that behavour of this
simpler case is too different from the behavour specified by the
input.
That you cannot understand that Pseudo_HHH(DD)
is a valid proxy for the execution trace of HHH(DD)
does not mean that I am incorrect.
On 8/30/2025 3:35 AM, Fred. Zwarts wrote:
Op 29.aug.2025 om 15:45 schreef olcott:
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
Counter factual. You never even tried to show me wrong.
When I prove that you are wrong and you cannot
understand this proof that does not mean that
I did not prove that you are wrong.
That HHH does get the correct answer on some
inputs proves that the notion of simulating
termination analyzer is correct.
You injected your prejudice that HHH aborts because it detects a non-
termination behaviour pattern, when in fact HHH prematurely aborts due
to a bug which makes that it does not see the difference between a
finite recursion and a non-termination behaviour pattern. It aborts
when it sees only a finite recursion and, without evidence, assumes
that it is a non-termination pattern.
Conclusion based on such incorrect assumptions have no value.
On 8/31/2025 5:53 AM, Fred. Zwarts wrote:
Op 30.aug.2025 om 17:57 schreef olcott:
On 8/30/2025 3:35 AM, Fred. Zwarts wrote:
Op 29.aug.2025 om 15:45 schreef olcott:
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
Counter factual. You never even tried to show me wrong.
When I prove that you are wrong and you cannot
understand this proof that does not mean that
I did not prove that you are wrong.
You never tried to show me wrong, so as usual irrelevant claims.
That HHH does get the correct answer on some
inputs proves that the notion of simulating
termination analyzer is correct.
As usual incorrect claims.
That HHH happens to return a correct result for some inputs does not
prove that. In particular when it fails for other inputs.
int main() {
return HHH(main);
}
Your own words are that HHH halts and returns that it does not halt.
This is what we call a false negative. HHH produces false negatives.
Not always uin many cases, in particular when it has to simulate code
that resembles its own code.
*Best selling author of theory of computation text books*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
HHH(main) would not stop running unless aborted.
You injected your prejudice that HHH aborts because it detects a
non- termination behaviour pattern, when in fact HHH prematurely
aborts due to a bug which makes that it does not see the difference
between a finite recursion and a non-termination behaviour pattern.
It aborts when it sees only a finite recursion and, without
evidence, assumes that it is a non-termination pattern.
Conclusion based on such incorrect assumptions have no value.
Op 31.aug.2025 om 17:48 schreef olcott:
On 8/31/2025 5:53 AM, Fred. Zwarts wrote:
Op 30.aug.2025 om 17:57 schreef olcott:
That HHH does get the correct answer on some
inputs proves that the notion of simulating
termination analyzer is correct.
HHH(main) would not stop running unless aborted.
And it does abort,
so it does stop.
On 8/31/2025 5:53 AM, Fred. Zwarts wrote:
Op 30.aug.2025 om 17:57 schreef olcott:
On 8/30/2025 3:35 AM, Fred. Zwarts wrote:
Op 29.aug.2025 om 15:45 schreef olcott:
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then
HHH is analyzing the structurally equivalent relationship
between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive
simulation is equivalent to recursion. Five LLM systems and
Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of
DD correctly simulated by HHH as essentially the same as
the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
Counter factual. You never even tried to show me wrong.
When I prove that you are wrong and you cannot
understand this proof that does not mean that
I did not prove that you are wrong.
You never tried to show me wrong, so as usual irrelevant claims.
That HHH does get the correct answer on some
inputs proves that the notion of simulating
termination analyzer is correct.
As usual incorrect claims.
That HHH happens to return a correct result for some inputs does not
prove that. In particular when it fails for other inputs.
int main() {
return HHH(main);
}
Your own words are that HHH halts and returns that it does not halt.
This is what we call a false negative. HHH produces false negatives.
Not always uin many cases, in particular when it has to simulate code
that resembles its own code.
*Best selling author of theory of computation text books*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
HHH(main) would not stop running unless aborted.
You injected your prejudice that HHH aborts because it detects a
non- termination behaviour pattern, when in fact HHH prematurely
aborts due to a bug which makes that it does not see the difference
between a finite recursion and a non-termination behaviour pattern.
It aborts when it sees only a finite recursion and, without
evidence, assumes that it is a non-termination pattern.
Conclusion based on such incorrect assumptions have no value.
On 9/1/2025 1:21 AM, Fred. Zwarts wrote:
Op 31.aug.2025 om 17:48 schreef olcott:
On 8/31/2025 5:53 AM, Fred. Zwarts wrote:
Op 30.aug.2025 om 17:57 schreef olcott:
On 8/30/2025 3:35 AM, Fred. Zwarts wrote:
Op 29.aug.2025 om 15:45 schreef olcott:
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then >>>>>>>>>>> HHH is analyzing the structurally equivalent relationship >>>>>>>>>>> between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive >>>>>>>>>>> simulation is equivalent to recursion. Five LLM systems and >>>>>>>>>>> Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of >>>>>>>>>>> DD correctly simulated by HHH as essentially the same as >>>>>>>>>>> the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
Counter factual. You never even tried to show me wrong.
When I prove that you are wrong and you cannot
understand this proof that does not mean that
I did not prove that you are wrong.
You never tried to show me wrong, so as usual irrelevant claims.
That HHH does get the correct answer on some
inputs proves that the notion of simulating
termination analyzer is correct.
As usual incorrect claims.
That HHH happens to return a correct result for some inputs does not
prove that. In particular when it fails for other inputs.
int main() {
return HHH(main);
}
Your own words are that HHH halts and returns that it does not halt.
This is what we call a false negative. HHH produces false negatives.
Not always uin many cases, in particular when it has to simulate
code that resembles its own code.
*Best selling author of theory of computation text books*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
HHH(main) would not stop running unless aborted.
And it does abort, so it does stop.
You must just be a troll.
never stop running unless aborted
never stop running unless aborted
never stop running unless aborted
never stop running unless aborted
never stop running unless aborted
On 9/1/2025 1:21 AM, Fred. Zwarts wrote:As usual repeated irrelevant claims without evidence.
Op 31.aug.2025 om 17:48 schreef olcott:
On 8/31/2025 5:53 AM, Fred. Zwarts wrote:
Op 30.aug.2025 om 17:57 schreef olcott:
On 8/30/2025 3:35 AM, Fred. Zwarts wrote:
Op 29.aug.2025 om 15:45 schreef olcott:
On 8/29/2025 2:55 AM, Fred. Zwarts wrote:
Op 28.aug.2025 om 16:04 schreef olcott:
On 8/28/2025 1:59 AM, Fred. Zwarts wrote:
Op 27.aug.2025 om 19:38 schreef olcott:
If HHH analyzes the behavior of DD correctly simulated
by HHH as HHH calls DD() instead of HHH simulates DD then >>>>>>>>>>> HHH is analyzing the structurally equivalent relationship >>>>>>>>>>> between HHH and DD.
How could HHH do this?
HHH would have to be smart enough to know that recursive >>>>>>>>>>> simulation is equivalent to recursion. Five LLM systems and >>>>>>>>>>> Richard Heathfield are this smart.
Then it is easy for HHH to determine the execution trace of >>>>>>>>>>> DD correctly simulated by HHH as essentially the same as >>>>>>>>>>> the trace of DD that calls HHH(DD) that calls DD().
<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.
Here olcott injects his prejudice into the system.
I proved that such an HHH works correctly with
several inputs thus proving that you are a liar.
As usual irrelevant claims.
I just proved that I did not inject prejudice into
the system cancelling your objection.
Counter factual. You never even tried to show me wrong.
When I prove that you are wrong and you cannot
understand this proof that does not mean that
I did not prove that you are wrong.
You never tried to show me wrong, so as usual irrelevant claims.
That HHH does get the correct answer on some
inputs proves that the notion of simulating
termination analyzer is correct.
As usual incorrect claims.
That HHH happens to return a correct result for some inputs does not
prove that. In particular when it fails for other inputs.
int main() {
return HHH(main);
}
Your own words are that HHH halts and returns that it does not halt.
This is what we call a false negative. HHH produces false negatives.
Not always uin many cases, in particular when it has to simulate
code that resembles its own code.
*Best selling author of theory of computation text books*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
HHH(main) would not stop running unless aborted.
And it does abort, so it does stop.
You must just be a troll.
never stop running unless aborted
never stop running unless aborted
never stop running unless aborted
never stop running unless aborted
never stop running unless aborted
Op 01.sep.2025 om 16:59 schreef olcott:
never stop running unless abortedAs usual repeated irrelevant claims without evidence.
It does abort, so it does stop.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 04:20:00 |
| Calls: | 10,386 |
| Calls today: | 1 |
| Files: | 14,057 |
| Messages: | 6,416,606 |