From Newsgroup: comp.theory

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.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 27/08/2025 18:38, olcott wrote:

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.

<ROTFL! Talk about damning with faint praise!>


<snip>

What value should HHH(DD) correctly return?

You say 0, right? I'll buy that.

$ cat dd.c
#include <stdio.h>

#define HHH(x) 0

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{
int hhh = HHH(DD);
int dd = DD();

printf("Because we got here, we know that both HHH and DD
halted.\n");

printf("But is that what they claim?\n\n");
printf("HHH(DD) yields %d (%s).\n",
hhh,
hhh ?
"halted" :
"incorrect claim of non-halting");

printf("DD yields %d (%s).\n",
dd,
dd ?
"halted" :
"incorrect claim of non-halting");

return 0;
}
$ gcc -o dd dd.c
$ ./dd
Because we got here, we know that both HHH and DD halted.
But is that what they claim?

HHH(DD) yields 0 (incorrect claim of non-halting).
DD yields 0 (incorrect claim of non-halting).

So DD halts.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/27/2025 12:58 PM, Richard Heathfield wrote:

On 27/08/2025 18:38, olcott wrote:

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.

<ROTFL! Talk about damning with faint praise!>

<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.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/27/2025 2:15 PM, olcott wrote:

On 8/27/2025 12:58 PM, Richard Heathfield wrote:

On 27/08/2025 18:38, olcott wrote:

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.

<ROTFL! Talk about damning with faint praise!>


<snip>

What value should HHH(DD) correctly return?

You say 0, right? I'll buy that.

All halt deciders

i.e. algorithms that meet these requirements:


Given any algorithm (i.e. a fixed immutable sequence of instructions) X described as <X> with input Y:

A solution to the halting problem is an algorithm H that computes the following mapping:

(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly

only report on the behavior
that their input finite string specifies

And the finite string DD is defined to specify algorithm DD which halts.

and
don't give a rat's ass about any damn thing
else such as that DD() halts.

False, see above.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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.

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.

And it can't, so it doesn't.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 27/08/2025 19:50, olcott wrote:

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

Kaz seems happy enough to accept that correspondence and see a
Turing machine where all I see is woeful C written by someone who
doesn't even know what a string is. What Kaz sees is up to Kaz,
but if you want to persuade me you'll have to do better than tell
lies about C's data types.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/27/25 1:38 PM, olcott wrote:

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.

Which only makes sense if HHH does in fact correctly simulate its input,
or it is just based on a lie that the HHH being called isn't the HHH
that was actually being called.

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.

You mean too dumb to understand that if it aborts its simulation, so
will the correct simulation of another copy of it on the same input.

Or, that it lies to itself that the HHH that it sees isn't the same HHH
as its code defines.

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().

You mean for it to determine the LIE about an input that isn't actualy
what it was given.

<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern:
-a-a-a abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement:
-a-a-a return 1.

typedef int (*ptr)();
int HHH(ptr P);

int DD()
{
-a int Halt_Status = HHH(DD);
-a if (Halt_Status)
-a-a-a HERE: goto HERE;
-a 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.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/27/25 2:50 PM, olcott wrote:

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.

Whose meaning is defined by the rules of representation of the machine.

And the finite string must be built of the symbol set of the machine.

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.

But Turing Machines don't have pointers.

And just the value of the pointer doesn't give the Turing Machine access
to the code at that address, that would need to be added to the string too.

And it can't, so it doesn't.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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:
-a-a-a abort simulation and return 0.

Here olcott injects his prejudice into the system. He uses the claim to
be proven as a prerequisite. That causes a circular invalid reasoning.
In fact, HHH does not detect a non-termination pattern, because no such pattern is present in the input.
HHH has a bug, which makes that when it sees a finite recursion, it
pretends that there is a non-termination pattern.
The bug is that it does not analyse the conditional branch instructions encountered during the simulation. When is stops the simulation, it
cannot claim that there is non-termination behaviour, unless it proves
that the alternate branches cannot possibly be followed in a correct continuation of the simulation, but that proof is not present. HHH
simply pretends that na on-termination behaviour pattern is detected
without any evidence.
Olcott has been pointed to this bug several times,. He has no counter-arguments, therefore he avoids the discussion about it.
Probably he will ignore it this time again and pretend that it does not
exist.

(b) Simulated input reaches its simulated "return" statement:
-a-a-a return 1.

typedef int (*ptr)();
int HHH(ptr P);

int DD()
{
-a int Halt_Status = HHH(DD);
-a if (Halt_Status)
-a-a-a HERE: goto HERE;
-a 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.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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. If HHH calls DD
and DD does not halt then HHH doesn't halt, either and is
not a decider. However, if HHH simulates DD it can discontinue
the simulation and therefore can always return, possibly with
a wrong return value.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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:
-a-a-a-a 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);
}
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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
and DD does not halt then HHH doesn't halt, either and is
not a decider. However, if HHH simulates DD it can discontinue
the simulation and therefore can always return, possibly with
a wrong return value.

int Simulate(ptr x)
{
x();
return 1;
}

int DD()
{
int Halt_Status = Simulate(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

HHH(DD) does recognize and rejects the same behavior pattern.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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?
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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!
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 28/08/2025 16:00, olcott wrote:

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()
{
-a Infinite_Recursion();
-a return;
}

void Infinite_Loop()
{
-a HERE: goto HERE;
-a OutputString("I never get here you dumb bunny!\n");
-a return;
}

These simulations halt too you dumb bunny!

So when you say "non-halting" you mean "halting". Got it.

Clearly you think the states are interchangeable.

Hell, no wonder you're confused.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/28/2025 10:29 AM, 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.

-aIf HHH calls DD
and DD does not halt then HHH doesn't halt, either and is
not a decider. However, if HHH simulates DD it can discontinue
the simulation and therefore can always return, possibly with
a wrong return value.

int Simulate(ptr x)
{
-a x();
-a return 1;
}

int DD()
{
-a int Halt_Status = Simulate(DD);
-a if (Halt_Status)
-a-a-a HERE: goto HERE;
-a return Halt_Status;
}

HHH(DD) does recognize and rejects the same behavior pattern.

Changing the input and deciding on that non-input is not allowed.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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.
Therfore it cannot see whether there is any non-halting pattern in
the behaviour of DD. Unless DD returns HHH cannot do anything. If
DD returns no non-halting pattern is needed ans the answer is already
known. HHH cannot do any better than

int HHH(ptr x)
{
x();
return 1;
}

If HHH simulates DD it can observe details of the behaviour and
compare them to known patterns.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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:
-a-a-a-a 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.

void Infinite_Recursion()
{
-a Infinite_Recursion();
-a return;
}

void Infinite_Loop()
{
-a HERE: goto HERE;
-a return;
}

int factorial(int n)
{
-a if (n >= 1)
-a-a-a return n*factorial(n-1);
-a else
-a-a-a return 1;
}

int factorial_caller()
{
-a factorial(5);
}

Finding three examples for which HHH happens to generate a correct
result does not prove anything. In particular when we see that HHH fails
in other cases.
One example of HHH failing is a proof that it is incorrect. Even 100
examples where HHH is correct does not prove that HHH is always correct.

int main() {
return HHH(main);
}

Here HHHH halts, but it reports that it does not halt. This is a simple
proof that HHH produces false negatives in some cases.

You know that HHH has a bug: It does not properly analyse the
conditional branch instructions encountered during the simulation. When
it aborts it does not prove that the alternative branches will never be followed when the simulation would have been continued correctly.
Therefore HHH *assumes*, without evidence, that it is correct when it
reports non-termination behaviour.
This assumption cannot be used as a proof that HHH is correct. That
would be invalid circular reasoning.
You could not come up with a counter argument, therefore you choose to
ignore this logic.
That is your attitude: close your eyes for the facts and claim that they
do not exist.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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:
-a-a-a-a 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.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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.

Therfore it cannot see whether there is any non-halting pattern in
the behaviour of DD. Unless DD returns HHH cannot do anything. If
DD returns no non-halting pattern is needed ans the answer is already
known. HHH cannot do any better than

int HHH(ptr x)
{
-a x();
-a return 1;
}

If HHH simulates DD it can observe details of the behaviour and
compare them to known patterns.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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:
-a-a-a-a 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.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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:
-a-a-a-a 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.

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.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/29/25 9:45 AM, olcott wrote:

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:
-a-a-a-a 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 didn't. as you HHH give the wrong answer for a Halt Decider, the
topic of your proof.

And, you are showing that your concept of computing is mostly worthless,
as programs CAN'T use the actual semantic meaning of the input.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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:
-a-a-a-a 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.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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:
-a-a-a-a 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.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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)
{
-a-a x();
-a-a return 1;
}

int DD()
{
-a-a int Halt_Status = Pseudo_HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a 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.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/30/25 11:59 AM, olcott wrote:

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:
-a-a-a-a 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.

Except that the answer isn't correct for a Halt Decider, as Halt
Deciders need to report on the behavior of the program described by the
input. not your categorical error non-program simulation of a
non-program represented to it.

All you have proven is that partial POOP deciders exist.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/30/25 11:57 AM, olcott wrote:

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:
-a-a-a-a 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.

But your when is never, as you lie about about you are doing.

That HHH does get the correct answer on some
inputs proves that the notion of simulating
termination analyzer is correct.

Nope. Fallicy of proof by example. You can't prove a universal from a
finite set of examples.

All you are doing is proving you don't undertstand what you are talking
about, and are too stupid to understand how logic works.

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.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 30/08/2025 16:57, olcott wrote:

That HHH does get the correct answer on some
inputs proves that the notion of simulating
termination analyzer is correct.

int HHHHHHHH(int (*P)(void))
{
return rand() % 2;
}

That HHHHHHHH does get the correct answer on some
inputs proves that the notion of randomising
termination analyzer is correct.

Bullshit.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-08-30 15:59:45 +0000, olcott said:

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:
-a-a-a-a 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.

Better termination analyzers are already known to exist.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-08-30 15:57:42 +0000, olcott said:

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:
-a-a-a-a 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 you don't understand that your "proofs" are shown to be
non-proofs does not mean that your "proofs" are proofs.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-08-30 16:02:49 +0000, olcott said:

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)
{
-a-a x();
-a-a return 1;
}

int DD()
{
-a-a int Halt_Status = Pseudo_HHH(DD);
-a-a if (Halt_Status)
-a-a-a-a HERE: goto HERE;
-a-a 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.

That you cannot understand that Pseudo_HHH(DD)is
an invalid proxy for the execution trace of HHH(DD)
does not mean that you are correct.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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:
-a-a-a-a 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.

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.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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:
-a-a-a-a 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.

-a-a-a-a-a-a int main() {
-a-a-a-a-a-a-a-a return HHH(main);
-a-a-a-a-a-a }

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.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 8/31/25 11:48 AM, olcott wrote:

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:
-a-a-a-a 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.

-a-a-a-a-a-a-a int main() {
-a-a-a-a-a-a-a-a-a return HHH(main);
-a-a-a-a-a-a-a }

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>
-a-a-a If simulating halt decider H correctly simulates its
-a-a-a input D until H correctly determines that its simulated D
-a-a-a would never stop running unless aborted then

-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a 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.

But "its simulated D specifies a non-halting sequence" is asking if
UTM(D) will halt, which it does if H(D) returns 0, so and H(D) that
returns 0 could not have CORRECTLY determine that its input will not
halt if correctly simulated.

You just don't unnderstand the meaning of the words.

Remember, that statement requires H and D to actually be PROGRAMS, and
thus H has fixed behavior of every given input, and D uses a specific
version of H, which by the proof that you claim to be refuting is the
ONE H that it is supposed to show gets the wrong answer, ie the one H
you are putting forward as correct.

Apparently a definition you can't understand.

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.

--- Synchronet 3.21a-Linux NewsLink 1.2