Re: Simulating termination analyzers by dummies --- What does halting mean?

On 6/21/2024 2:02 AM, Mikko wrote:

On 2024-06-20 14:45:17 +0000, olcott said:
 

On 6/20/2024 12:43 AM, Mikko wrote:

On 2024-06-19 13:11:10 +0000, olcott said:
>

On 6/19/2024 3:18 AM, Fred. Zwarts wrote:

Op 18.jun.2024 om 19:25 schreef olcott:

On 6/18/2024 12:06 PM, joes wrote:
>
void DDD()
{
   H0(DDD);
}
>
DDD correctly simulated by any H0 cannot possibly halt.
>

DDD halts iff H0 halts.

>
Halting is a technical term-of-the-art that corresponds
to terminates normally. Because Turing machines are
abstract mathematical objects there has been no notion
of abnormal termination for a Turing machine.
>
We can derive a notion of abnormal termination for Turing
machines from the standard terms-of-the-art.
>
Some TM's loop and thus never stop running, this is classical
non-halting behavior. UTM's simulate Turing machine descriptions.
This is the same thing as an interpreter interpreting the
source-code of a program.
>
A UTM can be adapted so that it only simulates a fixed number
of iterations of an input that loops. When this UTM stops
simulating this Turing machine description we cannot correctly
say that this looping input halted.
>

>
If the code specifies 5 iterations and the simulator simulates only 3 iterations, it is incorrect to conclude that the repetition show non-halting behaviour.

>
It is correct do say that the simulated input did not terminate
normally, thus defining the notion of abnormal termination
within Turing machines.

>
No, it is not. It is correct to say that the input was not simulated to its
normal termination.

>
void Infinite_Loop()
{
   HERE: goto HERE;
}
>
So infinite loops are beyond your comprehension.

 That I can make a reasonable comment about one point does not mean that
other points are beyond my comprehension. You should not assume that
other people's mental abilities are as limited as yours.
 

Bypassing my question.
I will assume that you do not understand that infinite loops
never terminate until you prove otherwise.

The input to the simulator is not a simulated input, it
is a real input.

>
A finite number of state transitions of a Turing Machine
description that loops are correctly simulated by an adapted UTM.
>
This adapted UTM stops simulating this input when it correctly
determines in a finite number of steps that this input loops
thus never halts.

 If it can. If the simulated Turing machine never returns to a previous
configuration it is hard to determine whether it will ever stop.

The executed H see all.

Even
a terminating computation may loop thorough the same internal states
but with a different tape content.
 

We cannot correctly say that this simulated looping input
terminated normally.

 We needn't if we can say that it was stuck in a loop. But there is no
method that can detect all possible non-terminating behaviours.
 

To refute the halting problem proofs H decides that
P correctly simulated by H never halts.
typedef int (*ptr2)();
int H(ptr2 P, ptr2 I);
int P(ptr2 x)
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
int main()
{
   H(P,P);
}

You have not defined "abnormal termination" of a Turing machine, nor
presented any reason to do so.

 

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer