Re: How do simulating termination analyzers work? ---Truth Maker Maximalism

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