From Newsgroup: comp.theory

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e
--
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 7/4/25 4:16 PM, olcott wrote:

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e

Since you LIE with the following statement;

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

Since there is no such pattern in the input, since its execution halts,
since HHH DOES return 0 as you stipulated, this statement is just a lie
of asserting the existance of a condition that doesn't exist.

Note, its first conclusion was:

Both analyzers correctly identify the termination behavior,
demonstrating that the halting problem's undecidability doesn't prevent practical termination analysis in specific cases where patterns can be detected.

Note the conditional WHERE PATTERS CAN BE DETECTED. Since there is no
correct pattern, HHH can't detect what doesn't exist, and thus if it
ACTUALLY did what you claimed was its algorithm, it would run forever
and fail to be a decider.

So, all you are doing is proving that you logic is based on lying, and
that AI isn't smart enough yet to detect that lie.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 7/4/2025 3:24 PM, Richard Damon wrote:

On 7/4/25 4:16 PM, olcott wrote:

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e

Since you LIE with the following statement;

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

Since there is no such pattern in the input, since its execution halts,

Directly executed Turing machines are outside of the
domain of every Turing machine partial halt decider,
thus DDD() does not contradict HHH(DDD)==0.

since HHH DOES return 0 as you stipulated, this statement is just a lie
of asserting the existance of a condition that doesn't exist.

Note, its first conclusion was:

Both analyzers correctly identify the termination behavior,
demonstrating that the halting problem's undecidability doesn't prevent practical termination analysis in specific cases where patterns can be detected.

Ah great so you didn't totally ignore what it said.

Note the conditional WHERE PATTERS CAN BE DETECTED. Since there is no correct pattern, HHH can't detect what doesn't exist, and thus if it ACTUALLY did what you claimed was its algorithm, it would run forever
and fail to be a decider.

It also said that it does detect this pattern itself.
It put that on its second page.

*Execution Trace of DD correctly simulated by HHH*
When HHH(DD) simulates DD:
1. HHH begins simulating DD
2. DD calls HHH(DD) - this creates a recursive simulation
3. HHH detects that simulating DD leads to DD calling HHH(DD) again
4. This creates an infinite recursive pattern: DD→HHH(DD)→DD→HHH(DD)→...

So, all you are doing is proving that you logic is based on lying, and
that AI isn't smart enough yet to detect that lie.

Not at all. This is merely you not paying close enough attention.
--
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

Op 05.jul.2025 om 00:08 schreef olcott:

On 7/4/2025 3:24 PM, Richard Damon wrote:

On 7/4/25 4:16 PM, olcott wrote:

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e

Since you LIE with the following statement;

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

Since there is no such pattern in the input, since its execution halts,

Directly executed Turing machines are outside of the
domain of every Turing machine partial halt decider,
thus DDD() does not contradict HHH(DDD)==0.

Irrelevant, because HHH should report on its input. This input includes
the abort code and specifies a halting program.
That is proven by direct execution of the same input, but there is no
need for the HHH to know about the direct execution.
The direct execution is only a proof of the failure of HHH.

since HHH DOES return 0 as you stipulated, this statement is just a
lie of asserting the existance of a condition that doesn't exist.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-07-04 20:16:34 +0000, olcott said:

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e

--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-07-04 20:16:34 +0000, olcott said:

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e

Perhaps an artificial idiot can think better than you but it does
not think better than most participants of these discussions.

What is not provable is not analytic truth. Opinions of artificial
idiots are not relevant. You have not proven any of your claims.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 7/4/25 6:08 PM, olcott wrote:

On 7/4/2025 3:24 PM, Richard Damon wrote:

On 7/4/25 4:16 PM, olcott wrote:

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e

Since you LIE with the following statement;

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

Since there is no such pattern in the input, since its execution halts,

Directly executed Turing machines are outside of the
domain of every Turing machine partial halt decider,
thus DDD() does not contradict HHH(DDD)==0.

Says what?

What about UTMs? They are Turing Machies, and there output *IS* the
behavior of the Directly executed Turing Machine.

Is arithmatic also outside of the domain of every Turing Machine since "numbers" can't be given to Turing Machines?

since HHH DOES return 0 as you stipulated, this statement is just a
lie of asserting the existance of a condition that doesn't exist.

Note, its first conclusion was:

Both analyzers correctly identify the termination behavior,
demonstrating that the halting problem's undecidability doesn't
prevent practical termination analysis in specific cases where
patterns can be detected.

Ah great so you didn't totally ignore what it said.

Yes, and I point out your errors, which YOU just totally ignore, as you
can't handle the truth.

Note the conditional WHERE PATTERS CAN BE DETECTED. Since there is no
correct pattern, HHH can't detect what doesn't exist, and thus if it
ACTUALLY did what you claimed was its algorithm, it would run forever
and fail to be a decider.

It also said that it does detect this pattern itself.
It put that on its second page.

Only because you told it a LIE that HHH DOES detect such a pattern.

*Execution Trace of DD correctly simulated by HHH*
When HHH(DD) simulates DD:
1. HHH begins simulating DD
2. DD calls HHH(DD) - this creates a recursive simulation
3. HHH detects that simulating DD leads to DD calling HHH(DD) again
4. This creates an infinite recursive pattern: DD→HHH(DD)→DD→HHH(DD)→...

Right, it used your LIE that this pattern is a non-halting patttern,
whne it isn't

So, all you are doing is proving that you logic is based on lying, and
that AI isn't smart enough yet to detect that lie.

Not at all. This is merely you not paying close enough attention.

Nope, YOU are the one with the problem.

Note, you have yet to actually answer any of my refutations, because you
just can't.

Your world is just based on lies.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 7/5/2025 4:06 AM, Mikko wrote:

On 2025-07-04 20:16:34 +0000, olcott said:

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e

Perhaps an artificial idiot can think better than you but it does
not think better than most participants of these discussions.

Yet you cannot point out any actual error.

What is not provable is not analytic truth.

I totally agree. Not only must it be provable it must
be provable semantically not merely syntactically.

Claude does provide the proof on the basis of understandings
that I provided to it. Here is the key new one:

Since no Turing machine can take another directly executing
Turing machine as an input they are outside of the domain
of any Turing machine based decider.

The requirement that a partial halt decider to report on the
behavior of a directly executed machine has always been bogus.

Opinions of artificial
idiots are not relevant. You have not proven any of your claims.

--
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 7/5/2025 2:43 AM, Fred. Zwarts wrote:

Op 05.jul.2025 om 00:08 schreef olcott:

On 7/4/2025 3:24 PM, Richard Damon wrote:

On 7/4/25 4:16 PM, olcott wrote:

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e

Since you LIE with the following statement;

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

Since there is no such pattern in the input, since its execution halts,

Directly executed Turing machines are outside of the
domain of every Turing machine partial halt decider,
thus DDD() does not contradict HHH(DDD)==0.

Irrelevant, because HHH should report on its input.

Thus you are agreeing with me and disagreeing with dbush
and many textbooks.

This input includes
the abort code and specifies a halting program.

*That is the part that is way over your head*
If HHH was reporting on its own termination status you
would be correct.

HHH(DD) is reporting on whether of not DD simulated by HHH
according to the semantics of the C programming language
can possibly reach its own simulated "return" statement.

void DDD()
{
HHH(DDD);
return;
}

DDD is the simplified version of DD().

That is proven by direct execution of the same input, but there is no
need for the HHH to know about the direct execution.
The direct execution is only a proof of the failure of HHH.

*No it is not proof of failure*
The requirement that halt deciders report on things outside
of their domain (directly executed machines) has always been
bogus. All directly executed Turing machines have always been
ouside of the domain of all Turing machine based deciders.

Claude understands this and agrees and sees this as a new idea.

since HHH DOES return 0 as you stipulated, this statement is just a
lie of asserting the existance of a condition that doesn't 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 7/5/2025 7:54 AM, Richard Damon wrote:

On 7/4/25 6:08 PM, olcott wrote:

On 7/4/2025 3:24 PM, Richard Damon wrote:

On 7/4/25 4:16 PM, olcott wrote:

https://claude.ai/share/48aab578-aec3-44a5-8bb3-6851e0f8b02e

Since you LIE with the following statement;

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

Since there is no such pattern in the input, since its execution halts,

Directly executed Turing machines are outside of the
domain of every Turing machine partial halt decider,
thus DDD() does not contradict HHH(DDD)==0.

Says what?

What about UTMs? They are Turing Machies, and there output *IS* the
behavior of the Directly executed Turing Machine.

To the best of my knowledge the behavior of the correct
simulation of an input is the same as its direct execution
except for the halting problem counter example input. The
"received view" of this is to simply give up on this input.
I did do better than that.

Is arithmatic also outside of the domain of every Turing Machine since "numbers" can't be given to Turing Machines?

since HHH DOES return 0 as you stipulated, this statement is just a
lie of asserting the existance of a condition that doesn't exist.

Note, its first conclusion was:

Both analyzers correctly identify the termination behavior,
demonstrating that the halting problem's undecidability doesn't
prevent practical termination analysis in specific cases where
patterns can be detected.

Ah great so you didn't totally ignore what it said.

Yes, and I point out your errors, which YOU just totally ignore, as you can't handle the truth.

Note the conditional WHERE PATTERS CAN BE DETECTED. Since there is no
correct pattern, HHH can't detect what doesn't exist, and thus if it
ACTUALLY did what you claimed was its algorithm, it would run forever
and fail to be a decider.

It also said that it does detect this pattern itself.
It put that on its second page.

Only because you told it a LIE that HHH DOES detect such a pattern.

*Execution Trace of DD correctly simulated by HHH*
When HHH(DD) simulates DD:
1. HHH begins simulating DD
2. DD calls HHH(DD) - this creates a recursive simulation
3. HHH detects that simulating DD leads to DD calling HHH(DD) again
4. This creates an infinite recursive pattern: DD→HHH(DD)→DD→HHH(DD)→...

Right, it used your LIE that this pattern is a non-halting patttern,
whne it isn't

You can't gaslight me on this any more.
Every chatbot found this pattern on its own without prompting.

So, all you are doing is proving that you logic is based on lying,
and that AI isn't smart enough yet to detect that lie.

Not at all. This is merely you not paying close enough attention.

Nope, YOU are the one with the problem.

Note, you have yet to actually answer any of my refutations, because you just can't.

Your world is just based on lies.

Maybe the doctrine that they teach at your church is
that you can get away with lies and Revelation 21:8 does
not apply to you. I am not taking that chance.
--
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