Re: Defining a correct simulating halt decider

On 9/8/24 8:57 AM, olcott wrote:

On 9/8/2024 7:46 AM, joes wrote:

Am Sat, 07 Sep 2024 08:57:00 -0500 schrieb olcott:

On 9/7/2024 3:29 AM, Mikko wrote:

On 2024-09-07 05:12:19 +0000, joes said:

Am Fri, 06 Sep 2024 06:42:48 -0500 schrieb olcott:

On 9/6/2024 6:19 AM, Mikko wrote:

On 2024-09-05 13:24:20 +0000, olcott said:

On 9/5/2024 2:34 AM, Mikko wrote:

On 2024-09-03 13:00:50 +0000, olcott said:

On 9/3/2024 5:25 AM, Mikko wrote:

On 2024-09-02 16:38:03 +0000, olcott said:
>

A halt decider is a Turing machine that computes the mapping
from its finite string input to the behavior that this finite
string specifies.

>
A halt decider needn't compute the full behaviour, only whether
that behaviour is finite or infinite.
>

New slave_stack at:1038c4 Begin Local Halt Decider Simulation
Local Halt Decider: Infinite Recursion Detected Simulation
Stopped
Hence  HHH(DDD)==0 is correct

>
Nice to see that you don't disagree with what said.
Unvortunately I can't agree with what you say.
HHH terminates,
os DDD obviously terminates, too. No valid

>
DDD emulated by HHH never reaches it final halt state.

>
If that iis true it means that HHH called by DDD does not return and
therefore is not a ceicder.

The directly executed HHH is a decider.

What does simulating it change about that?

>
If the simulation is incorrect it may change anything.
>

PATHOLOGICAL RELATIONSHIPS CHANGE BEHAVIOR

How? What is pathological?
>

 void DDD()
{
   HHH(DDD);
   return;
}
 That DDD calls its own emulator (a pathological relationship)

ERROR ERROR ERROR ERROR.
First, HHH is NOT "An Emulator" but you are claiming it to be "a halt decider". There is a difference, which to ignore is just a lie.
The two things have different requirements, an emulator needs to act just as the machine it is emulating, and thus CAN NOT ABORT its emulation, as the "correct emulaiton" of a non-halting program is to be non-halting.
A Halt Decider, on the other hand, MUST ANSWER in finite time, so if its input is non-halting, it MUST ABORT, so as to answer.
To confuse the two is to express stupidity.
Second, DDD doesn't have "its own emulator", it has no idea that it is being emulated, or by who. It is asking a particular halt decider to decide on an input that happens to be a representation of itself. This, by itself, is not "pathological", but does require a "smarter" form of decider to handle it (for instance, the Flibble method).
Since, the definition of a Halt Decider is that it can take as an input the description of ANY program, then it becomes incumbent on the decider to handle cases that might be "pathological" (as there is no escape clause for that in "Any Program"). The more properly pathological program that does the opposite of what the decider says, shows that the problem can't be computed, as we can make an input for every possible decider that it must get wrong.

makes this DDD and HHH stuck in infinite recursive emulation
unless the outermost HHH aborts its emulation at some point.

But once you make HHH do that to avoid the problem, then the DDD will be calling THAT HHH, and thus DDD will have always been halting. Since HHH must decide on the input it is given, which uses THIS HHH, it can't answer about a DDD that calls some other HHH.

 Whether HHH aborts its emulation at some point or not DDD
never reaches its final halt state of "return", thus DDD
cannot possibly halt no matter what HHH does.

No, as has been shown, if HHH aborts and returns, then the direct execution of DDD or the correct emulation of DDD WILL reach that return.
You are just repeating your lie based on the false assumption that we are looking at just the emulation that HHH does, but that is just your own strawman and a lie.

 When HHH sees this it aborts DDD and correctly reports that
it emulated DDD is non halting.
 

And, because it does that based on false assumption, it is ust using invalid logic, proving you are nothing but a LIAR.
Sorry, that is the facts, you are just proving you are so stupid that you can not learn what the the actual definitions of the problem are, because you have brainwashed yourself with your lies.