Re: Proving the: Simulating termination analyzer Principle

On 4/5/2025 8:43 PM, olcott wrote:

On 4/5/2025 7:34 PM, dbush wrote:

On 4/5/2025 8:30 PM, olcott wrote:

On 4/5/2025 5:27 PM, dbush wrote:

On 4/5/2025 6:18 PM, Richard Heathfield wrote:

On 05/04/2025 22:31, dbush wrote:

On 4/5/2025 5:29 PM, olcott wrote:

On 4/5/2025 4:15 PM, dbush wrote:

On 4/5/2025 4:52 PM, olcott wrote:

*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.
>
void DDD()
{
    HHH(DDD);
    return;
}

>
Except when doing so would change the input, as is the case with HHH and DDD.
>
Changing the input is not allowed.

>
You may disagree that the above definition
of simulating termination analyzer is correct.
>
It is self-evident that HHH must stop simulating
DDD to prevent its own non-termination.
>

>
Changing the input is not allowed.

>
You're right, but it doesn't matter very much as long as terminates() *always* gets the answer right for any arbitrary program tape and any data tape. Mr Olcott's fails to do that.
>

>
Of course you're correct. His criteria is basically what happens if you replace the code of X with a pure simulator and run X(Y) for some Y.
>

>
Everyone else seems to think that the correct way
to handle a pathological relationship between an
input and a termination analyzer is to simply ignore
the differences that this makes. THAT CAN'T BE RIGHT !!!
>

>
Ignoring the relationship is exactly what you do when you change the code of HHH, thereby changing the input.
>
Changing the input is not allowed.

 Ignoring the fact that the pathological
relationship between the input and the
termination analyzer changes the behavior
of the input is certainly incorrect.
 Giving up and saying nothing can be done
also seems incorrect.
 What else is left?
 

Realizing that the halting function is not a computable function, i.e no algorithm exists that computes the required mapping:
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