From Newsgroup: comp.theory

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

Am Thu, 03 Jul 2025 17:11:45 -0500 schrieb olcott:

On 7/2/2025 1:53 AM, Mikko wrote:

On 2025-07-01 11:46:11 +0000, olcott said:

It is relevant to the halting problem because no input to a halt
decider can possibly do the opposite of whatever its halt decider
decides. The thing that does the opposite is not an input.

You are effectively saying that all programs that start with a call to
HHH are the same.

It is irrelevant because the halting problem clarly states that the
input is a description of a Turing machine and an input to that
machine. You may say that to decide halting of a directly executed
Turing machnie is not possible from the given input but the problem
is what it is.

Although it is called a description that term is inaccurate.
It leads people to believe that 98% of exactly what it does is close
enough. That DD() *DOES NOT DO* what DD correctly simulated by HHH
does is a key detail *THAT ALWAYS ESCAPES THEM*

WTH? It is rather obvious that HHH cannot simulate DDD or anything else
that calls HHH the same way as that input when run "directly".

It is actually has 100% of all of the details that the machine code of >>>> DD has. The input to HHH(DD) *SPECIFIES*
100% of every detail of the exactly behavior *OF THIS INPUT*

Yeah, and you can also execute that code instead of simulating it.

Yes. So it is like this:
*The input to HHH(DD) specifies non-halting behavior*
The directly executed DD() is not an input.

Of course not, its code is.

Because it is not an input it HHH is not accountable for its behavior.
Deciders are only accountable for computing the mapping from their
inputs.

Yes it is, HHH should compute whether the code of DD halts when run.

Likewise we should also compute the area of
a square circle with a radius of 2.

Partial halt deciders have never been allowed to
report on the behavior of any directly executed
Turing machine. Instead of this they have used
the behavior that their input machine description
specifies as a proxy.

This has seemed to be a perfect proxy until my
invention of simulating partial halt deciders.

Now for the first time we see that DDD correctly
simulated by HHH *IS NOT A PROXY* for the behavior
of the directly executed DDD().

Because all deciders are required to compute the
mapping *FROM THEIR INPUTS* and DDD() is not an
input then DDD correctly simulated by HHH is the
behavior that HHH must report on and the behavior
of the directly executed DDD() can be ignored.

You can't be thinking that is uncomputable.

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

Am Fri, 04 Jul 2025 12:30:43 -0500 schrieb olcott:

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

Am Thu, 03 Jul 2025 17:11:45 -0500 schrieb olcott:

On 7/2/2025 1:53 AM, Mikko wrote:

On 2025-07-01 11:46:11 +0000, olcott said:

You are effectively saying that all programs that start with a call
to HHH are the same.

Did I misunderstand you?

Because it is not an input it HHH is not accountable for its behavior.
Deciders are only accountable for computing the mapping from their
inputs.

Yes it is, HHH should compute whether the code of DD halts when run.
You can't be thinking that is uncomputable.

Likewise we should also compute the area of a square circle with a
radius of 2.

Are you seriously suggesting that you can't compute what the code of
DDD does when executed?

Partial halt deciders have never been allowed to report on the behavior
of any directly executed Turing machine. Instead of this they have used
the behavior that their input machine description specifies as a proxy.

And you think that DDD's direct execution is not specified by its
description?

Now for the first time we see that DDD correctly simulated by HHH *IS
NOT A PROXY* for the behavior of the directly executed DDD().

Indeed, HHH does not simulate it correctly. (You can't mean that DDD
is *executed* incorrectly.)
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 7/4/2025 1:23 PM, joes wrote:

Am Fri, 04 Jul 2025 12:30:43 -0500 schrieb olcott:

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

Am Thu, 03 Jul 2025 17:11:45 -0500 schrieb olcott:

On 7/2/2025 1:53 AM, Mikko wrote:

On 2025-07-01 11:46:11 +0000, olcott said:

You are effectively saying that all programs that start with a call
to HHH are the same.

Did I misunderstand you?

The nesting is too deep to see
what you are responding to.

Because it is not an input it HHH is not accountable for its behavior. >>>> Deciders are only accountable for computing the mapping from their
inputs.

Yes it is, HHH should compute whether the code of DD halts when run.
You can't be thinking that is uncomputable.

Likewise we should also compute the area of a square circle with a
radius of 2.

Are you seriously suggesting that you can't compute what the code of
DDD does when executed?

Partial halt deciders have never been allowed to report on the behavior
of any directly executed Turing machine. Instead of this they have used
the behavior that their input machine description specifies as a proxy.

And you think that DDD's direct execution is not specified by its description?

I HAVE PROVEN THAT DDD CORRECTLY SIMULATED BY
HHH DOES NOT HAVE THE SAME BEHAVIOR AS DDD()
THOUSANDS OF TIMES IN THE LAST THREE YEARS

Now for the first time we see that DDD correctly simulated by HHH *IS
NOT A PROXY* for the behavior of the directly executed DDD().

Indeed, HHH does not simulate it correctly. (You can't mean that DDD
is *executed* incorrectly.)

You are using the wrong measure of correct.
A correct simulation is not whatever simulation
matches your expectations.

The semantics of the x86 language is the ultimate
measure of correct emulation.

Disagreeing with this is like disagreeing that
2 + 3 = 5 is true because you "doan beeve in nummers"
--
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

Am Fri, 04 Jul 2025 13:37:25 -0500 schrieb olcott:

On 7/4/2025 1:23 PM, joes wrote:

Am Fri, 04 Jul 2025 12:30:43 -0500 schrieb olcott:

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

You are effectively saying that all programs that start with a call >>>>>> to HHH are the same.

The nesting is too deep to see what you are responding to.

Lol, you could have responded immediately. You know how to look up posts.

Yes it is, HHH should compute whether the code of DD halts when run.
You can't be thinking that is uncomputable.

Likewise we should also compute the area of a square circle with a
radius of 2.

Are you seriously suggesting that you can't compute what the code of
DDD does when executed?

Don't complain later.

Partial halt deciders have never been allowed to report on the
behavior of any directly executed Turing machine. Instead of this they
have used the behavior that their input machine description specifies
as a proxy.

And you think that DDD's direct execution is not specified by its
description?

I HAVE PROVEN THAT DDD CORRECTLY SIMULATED BY HHH DOES NOT HAVE THE SAME BEHAVIOR AS DDD() THOUSANDS OF TIMES IN THE LAST THREE YEARS

No disagreement; not my question.

Now for the first time we see that DDD correctly simulated by HHH *IS
NOT A PROXY* for the behavior of the directly executed DDD().

Indeed, HHH does not simulate it correctly. (You can't mean that DDD is
*executed* incorrectly.)

You are using the wrong measure of correct.

So DDD specifies at least two different behaviours?
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 7/4/2025 2:09 PM, joes wrote:

Am Fri, 04 Jul 2025 13:37:25 -0500 schrieb olcott:

On 7/4/2025 1:23 PM, joes wrote:

Am Fri, 04 Jul 2025 12:30:43 -0500 schrieb olcott:

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

You are effectively saying that all programs that start with a call >>>>>>> to HHH are the same.

The nesting is too deep to see what you are responding to.

Lol, you could have responded immediately. You know how to look up posts.

Yes it is, HHH should compute whether the code of DD halts when run. >>>>> You can't be thinking that is uncomputable.

Likewise we should also compute the area of a square circle with a
radius of 2.

Are you seriously suggesting that you can't compute what the code of
DDD does when executed?

Don't complain later.

Partial halt deciders have never been allowed to report on the
behavior of any directly executed Turing machine. Instead of this they >>>> have used the behavior that their input machine description specifies
as a proxy.

And you think that DDD's direct execution is not specified by its
description?

I HAVE PROVEN THAT DDD CORRECTLY SIMULATED BY HHH DOES NOT HAVE THE SAME
BEHAVIOR AS DDD() THOUSANDS OF TIMES IN THE LAST THREE YEARS

No disagreement; not my question.

Now for the first time we see that DDD correctly simulated by HHH *IS
NOT A PROXY* for the behavior of the directly executed DDD().

Indeed, HHH does not simulate it correctly. (You can't mean that DDD is
*executed* incorrectly.)

You are using the wrong measure of correct.

So DDD specifies at least two different behaviours?

*Yes. This sums it up quite well* (its only 1.5 pages long) https://claude.ai/share/da9b8e3f-eb16-42ca-a9e8-913f4b88202c
--
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 3:15 PM, olcott wrote:

On 7/4/2025 2:09 PM, joes wrote:

Am Fri, 04 Jul 2025 13:37:25 -0500 schrieb olcott:

On 7/4/2025 1:23 PM, joes wrote:

Am Fri, 04 Jul 2025 12:30:43 -0500 schrieb olcott:

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

You are effectively saying that all programs that start with a call >>>>>>>> to HHH are the same.

The nesting is too deep to see what you are responding to.

Lol, you could have responded immediately. You know how to look up posts.

Yes it is, HHH should compute whether the code of DD halts when run. >>>>>> You can't be thinking that is uncomputable.

Likewise we should also compute the area of a square circle with a
radius of 2.

Are you seriously suggesting that you can't compute what the code of
DDD does when executed?

Don't complain later.

Partial halt deciders have never been allowed to report on the
behavior of any directly executed Turing machine. Instead of this they >>>>> have used the behavior that their input machine description specifies >>>>> as a proxy.

And you think that DDD's direct execution is not specified by its
description?

I HAVE PROVEN THAT DDD CORRECTLY SIMULATED BY HHH DOES NOT HAVE THE SAME >>> BEHAVIOR AS DDD() THOUSANDS OF TIMES IN THE LAST THREE YEARS

No disagreement; not my question.

Now for the first time we see that DDD correctly simulated by HHH *IS >>>>> NOT A PROXY* for the behavior of the directly executed DDD().

Indeed, HHH does not simulate it correctly. (You can't mean that DDD is >>>> *executed* incorrectly.)

You are using the wrong measure of correct.

So DDD specifies at least two different behaviours?

*Yes. This sums it up quite well* (its only 1.5 pages long) https://claude.ai/share/da9b8e3f-eb16-42ca-a9e8-913f4b88202c

Then your system LIES and is based on lies.

"Code" is deterministic, and thus every instruction when starting from
the same state will always do the same thing.

Since there will nevef be a specific instruction whose execution will
not match its "correct simulation" (or some other exectution path that
started from the same state) there can never be a divergence of results.

Your failure to point to an instruction ACTUALLY CORRECTLY simulated
that created a different results from the same step directly exectuted,
just points out that you know you are just lying, but can't admit it to yourself or the people you are talking to.

Sorry, you are just a sef-brainwashed gaslight liar that can't handle
the truth.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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

On 7/4/25 3:15 PM, olcott wrote:

On 7/4/2025 2:09 PM, joes wrote:

Am Fri, 04 Jul 2025 13:37:25 -0500 schrieb olcott:

On 7/4/2025 1:23 PM, joes wrote:

Am Fri, 04 Jul 2025 12:30:43 -0500 schrieb olcott:

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

You are effectively saying that all programs that start with a >>>>>>>>> call
to HHH are the same.

The nesting is too deep to see what you are responding to.

Lol, you could have responded immediately. You know how to look up
posts.

Yes it is, HHH should compute whether the code of DD halts when run. >>>>>>> You can't be thinking that is uncomputable.

Likewise we should also compute the area of a square circle with a >>>>>> radius of 2.

Are you seriously suggesting that you can't compute what the code of >>>>> DDD does when executed?

Don't complain later.

Partial halt deciders have never been allowed to report on the
behavior of any directly executed Turing machine. Instead of this >>>>>> they
have used the behavior that their input machine description specifies >>>>>> as a proxy.

And you think that DDD's direct execution is not specified by its
description?

I HAVE PROVEN THAT DDD CORRECTLY SIMULATED BY HHH DOES NOT HAVE THE
SAME
BEHAVIOR AS DDD() THOUSANDS OF TIMES IN THE LAST THREE YEARS

No disagreement; not my question.

Now for the first time we see that DDD correctly simulated by HHH *IS >>>>>> NOT A PROXY* for the behavior of the directly executed DDD().

Indeed, HHH does not simulate it correctly. (You can't mean that
DDD is
*executed* incorrectly.)

You are using the wrong measure of correct.

So DDD specifies at least two different behaviours?

*Yes. This sums it up quite well* (its only 1.5 pages long)
https://claude.ai/share/da9b8e3f-eb16-42ca-a9e8-913f4b88202c

Then your system LIES and is based on lies.

"Code" is deterministic, and thus every instruction when starting from
the same state will always do the same thing.

That you are not bright enough to detect the recursive
simulation non terminating behavior pattern is no rebuttal
at all.
--
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:26 schreef olcott:

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

On 7/4/25 3:15 PM, olcott wrote:

On 7/4/2025 2:09 PM, joes wrote:

Am Fri, 04 Jul 2025 13:37:25 -0500 schrieb olcott:

On 7/4/2025 1:23 PM, joes wrote:

Am Fri, 04 Jul 2025 12:30:43 -0500 schrieb olcott:

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

You are effectively saying that all programs that start with a >>>>>>>>>> call
to HHH are the same.

The nesting is too deep to see what you are responding to.

Lol, you could have responded immediately. You know how to look up
posts.

Yes it is, HHH should compute whether the code of DD halts when >>>>>>>> run.
You can't be thinking that is uncomputable.

Likewise we should also compute the area of a square circle with a >>>>>>> radius of 2.

Are you seriously suggesting that you can't compute what the code of >>>>>> DDD does when executed?

Don't complain later.

Partial halt deciders have never been allowed to report on the
behavior of any directly executed Turing machine. Instead of this >>>>>>> they
have used the behavior that their input machine description
specifies
as a proxy.

And you think that DDD's direct execution is not specified by its
description?

I HAVE PROVEN THAT DDD CORRECTLY SIMULATED BY HHH DOES NOT HAVE THE >>>>> SAME
BEHAVIOR AS DDD() THOUSANDS OF TIMES IN THE LAST THREE YEARS

No disagreement; not my question.

Now for the first time we see that DDD correctly simulated by HHH >>>>>>> *IS
NOT A PROXY* for the behavior of the directly executed DDD().

Indeed, HHH does not simulate it correctly. (You can't mean that
DDD is
*executed* incorrectly.)

You are using the wrong measure of correct.

So DDD specifies at least two different behaviours?

*Yes. This sums it up quite well* (its only 1.5 pages long)
https://claude.ai/share/da9b8e3f-eb16-42ca-a9e8-913f4b88202c

Then your system LIES and is based on lies.

"Code" is deterministic, and thus every instruction when starting from
the same state will always do the same thing.

That you are not bright enough to detect the recursive
simulation non terminating behavior pattern is no rebuttal
at all.

There is only *finite* recursive simulation, so everybody bright enough understands that there is no non-terminating behaviour.
Not understanding the difference between *finite* recursion and
*infinite* recursion shows who is not bright enough.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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

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

On 7/4/25 3:15 PM, olcott wrote:

On 7/4/2025 2:09 PM, joes wrote:

Am Fri, 04 Jul 2025 13:37:25 -0500 schrieb olcott:

On 7/4/2025 1:23 PM, joes wrote:

Am Fri, 04 Jul 2025 12:30:43 -0500 schrieb olcott:

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

You are effectively saying that all programs that start with a >>>>>>>>>> call
to HHH are the same.

The nesting is too deep to see what you are responding to.

Lol, you could have responded immediately. You know how to look up
posts.

Yes it is, HHH should compute whether the code of DD halts when >>>>>>>> run.
You can't be thinking that is uncomputable.

Likewise we should also compute the area of a square circle with a >>>>>>> radius of 2.

Are you seriously suggesting that you can't compute what the code of >>>>>> DDD does when executed?

Don't complain later.

Partial halt deciders have never been allowed to report on the
behavior of any directly executed Turing machine. Instead of this >>>>>>> they
have used the behavior that their input machine description
specifies
as a proxy.

And you think that DDD's direct execution is not specified by its
description?

I HAVE PROVEN THAT DDD CORRECTLY SIMULATED BY HHH DOES NOT HAVE THE >>>>> SAME
BEHAVIOR AS DDD() THOUSANDS OF TIMES IN THE LAST THREE YEARS

No disagreement; not my question.

Now for the first time we see that DDD correctly simulated by HHH >>>>>>> *IS
NOT A PROXY* for the behavior of the directly executed DDD().

Indeed, HHH does not simulate it correctly. (You can't mean that
DDD is
*executed* incorrectly.)

You are using the wrong measure of correct.

So DDD specifies at least two different behaviours?

*Yes. This sums it up quite well* (its only 1.5 pages long)
https://claude.ai/share/da9b8e3f-eb16-42ca-a9e8-913f4b88202c

Then your system LIES and is based on lies.

"Code" is deterministic, and thus every instruction when starting from
the same state will always do the same thing.

That you are not bright enough to detect the recursive
simulation non terminating behavior pattern is no rebuttal
at all.

So, how does a finite recursion, finite because every simulator in the
loop aborts its simulation at a given point, become non-halting.

Your problem is you treat an infinite set of different inputs as if they
were all the same (or you are "correctly simulating" a non-simulatable fragment by lying).

Your problem is you don't understand the meaning of the term.

Your problem is you don't understand the difference between what is
TRUTH (aka the direct execution of the machine) and a fantasy (aka the
results of a partial simulation with unsound extrapolation). But that is
your problem in life too, you just don't understand what reality and
truth actually are.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 7/5/2025 3:32 AM, Mikko wrote:

On 2025-07-04 12:34:39 +0000, olcott said:

On 7/4/2025 2:25 AM, Mikko wrote:

What HHH correctly or otherwise simulates is merely an implementation
detail.

It is a detail that defines a partial halt decider
that makes the "do the opposite" code unreachable.

No, it does. The proof that a counter-example can be constructed
does not refer to any implementation details, so it applies to
every implementation that is does not violate the requirements
so obviously that the proof is not needed.

What matters is the beahviour DD specifies.

The behavior that an input specifies is only correctly
measured by correctly simulating this input.

Wrong. It is correctly measured by a direct execution.

Since no Turing machine can possibly take another directly
executing Turing machine as an input this makes all directly
executed Turing machines outside of the domain of every Turing
machine based decider.

The requirement that a halt decider report on the behavior
of things outside of its domain has always been bogus.

Instead of this deciders must report on the behavior that
their input actually specifies. The input to HHH(DDD) specifies
recursive simulation that cannot possibly reach its own
simulated final state. Four chatbots figured this out on
their own, thus busted everyone here for gaslighting.

I also have two people with masters degrees in computer
science that both agreed to this years ago.
--
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:26 AM, Fred. Zwarts wrote:

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

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

On 7/4/25 3:15 PM, olcott wrote:

On 7/4/2025 2:09 PM, joes wrote:

Am Fri, 04 Jul 2025 13:37:25 -0500 schrieb olcott:

On 7/4/2025 1:23 PM, joes wrote:

Am Fri, 04 Jul 2025 12:30:43 -0500 schrieb olcott:

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

You are effectively saying that all programs that start with >>>>>>>>>>> a call
to HHH are the same.

The nesting is too deep to see what you are responding to.

Lol, you could have responded immediately. You know how to look up
posts.

Yes it is, HHH should compute whether the code of DD halts when >>>>>>>>> run.
You can't be thinking that is uncomputable.

Likewise we should also compute the area of a square circle with a >>>>>>>> radius of 2.

Are you seriously suggesting that you can't compute what the code of >>>>>>> DDD does when executed?

Don't complain later.

Partial halt deciders have never been allowed to report on the >>>>>>>> behavior of any directly executed Turing machine. Instead of
this they
have used the behavior that their input machine description
specifies
as a proxy.

And you think that DDD's direct execution is not specified by its >>>>>>> description?

I HAVE PROVEN THAT DDD CORRECTLY SIMULATED BY HHH DOES NOT HAVE
THE SAME
BEHAVIOR AS DDD() THOUSANDS OF TIMES IN THE LAST THREE YEARS

No disagreement; not my question.

Now for the first time we see that DDD correctly simulated by >>>>>>>> HHH *IS
NOT A PROXY* for the behavior of the directly executed DDD().

Indeed, HHH does not simulate it correctly. (You can't mean that >>>>>>> DDD is
*executed* incorrectly.)

You are using the wrong measure of correct.

So DDD specifies at least two different behaviours?

*Yes. This sums it up quite well* (its only 1.5 pages long)
https://claude.ai/share/da9b8e3f-eb16-42ca-a9e8-913f4b88202c

Then your system LIES and is based on lies.

"Code" is deterministic, and thus every instruction when starting
from the same state will always do the same thing.

That you are not bright enough to detect the recursive
simulation non terminating behavior pattern is no rebuttal
at all.

There is only *finite* recursive simulation, so everybody bright enough understands that there is no non-terminating behaviour.

*It has never been whether it is finite or infinite*
It has always been: Would DDD simulated by HHH reach
its simulated final halt state in an infinite simulation?

Not understanding the difference between *finite* recursion and
*infinite* recursion shows who is not bright enough.

No it shows that you are not bothering to pay close attention
or like Richard cannot remember anything that I ever said in
prior posts.
--
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 8:11 AM, Richard Damon wrote:

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

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

On 7/4/25 3:15 PM, olcott wrote:

On 7/4/2025 2:09 PM, joes wrote:

Am Fri, 04 Jul 2025 13:37:25 -0500 schrieb olcott:

On 7/4/2025 1:23 PM, joes wrote:

Am Fri, 04 Jul 2025 12:30:43 -0500 schrieb olcott:

On 7/4/2025 8:37 AM, joes wrote:

Am Fri, 04 Jul 2025 07:16:23 -0500 schrieb olcott:

On 7/4/2025 3:55 AM, joes wrote:

You are effectively saying that all programs that start with >>>>>>>>>>> a call
to HHH are the same.

The nesting is too deep to see what you are responding to.

Lol, you could have responded immediately. You know how to look up
posts.

Yes it is, HHH should compute whether the code of DD halts when >>>>>>>>> run.
You can't be thinking that is uncomputable.

Likewise we should also compute the area of a square circle with a >>>>>>>> radius of 2.

Are you seriously suggesting that you can't compute what the code of >>>>>>> DDD does when executed?

Don't complain later.

Partial halt deciders have never been allowed to report on the >>>>>>>> behavior of any directly executed Turing machine. Instead of
this they
have used the behavior that their input machine description
specifies
as a proxy.

And you think that DDD's direct execution is not specified by its >>>>>>> description?

I HAVE PROVEN THAT DDD CORRECTLY SIMULATED BY HHH DOES NOT HAVE
THE SAME
BEHAVIOR AS DDD() THOUSANDS OF TIMES IN THE LAST THREE YEARS

No disagreement; not my question.

Now for the first time we see that DDD correctly simulated by >>>>>>>> HHH *IS
NOT A PROXY* for the behavior of the directly executed DDD().

Indeed, HHH does not simulate it correctly. (You can't mean that >>>>>>> DDD is
*executed* incorrectly.)

You are using the wrong measure of correct.

So DDD specifies at least two different behaviours?

*Yes. This sums it up quite well* (its only 1.5 pages long)
https://claude.ai/share/da9b8e3f-eb16-42ca-a9e8-913f4b88202c

Then your system LIES and is based on lies.

"Code" is deterministic, and thus every instruction when starting
from the same state will always do the same thing.

That you are not bright enough to detect the recursive
simulation non terminating behavior pattern is no rebuttal
at all.

So, how does a finite recursion, finite because every simulator in the
loop aborts its simulation at a given point, become non-halting.

I told you this at least dozens of times, go look up
what I already said.
--
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