Re: Can D simulated by H terminate normally?

On 5/2/2024 4:07 AM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 4/29/2024 1:19 PM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 4/29/2024 11:17 AM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 4/29/2024 10:23 AM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 4/29/2024 9:37 AM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com> wrote:

On 4/28/2024 1:39 PM, Richard Damon wrote:

On 4/28/24 2:19 PM, olcott wrote:

 [ .... ]
 

A simulating termination analyzer is not the same thing as a UTM.

 

At the moment, on this newsgroup, it's a meaningless term.  You seem to
have used it merely as a synonym for halting decider in the past.  Yet
you fail to say what you mean by it, if you mean something different.

 

Within my brand new idea of a {simulating termination analyzer}
there is the idea of abnormal termination.

 

It's unlikely to be a brand new idea, whatever it might be, since you
aren't familiar with the literature and so most likely have come up with
somebody else's old idea.

 [ .... ]
 

You've failed, repeatedly, to address the points I've been making in my
last few posts, so it seems that you have accepted them.  In particular,
you have accepted that "having been aborted" is indeed a final state for
a turing machine or a program.

 

All of the "points" that you have been making were entirely anchored in
your ignorance about what "simulating termination analyzer" are and how
they work.

 I think it much more likely that there's no such thing as a "simulating
termination analyzer".

You say that when I my code proves that H does correctly
determine the halt status of these three inputs.
void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
}
void Infinite_Loop()
{
   HERE: goto HERE;
}
int factorial(int n)
{
   if (n >= 1)
     return n*factorial(n-1);
   else
     return 1;
}
int main()
{
   Output("Input_Halts = ", H(factorial, (ptr)5));
   Output("Input_Halts = ", H0(Infinite_Loop));
   Output("Input_Halts = ", H(Infinite_Recursion, (ptr)5));
}

I.e. there's no theory about it, no interesting
results, no use for it, or anything like that.  I've asked you several
times to define this object, other people have asked you too, yet you
fail to do so.  Producing a few lines of scrappy C code is not anything
like producing a definition.
 

When a simulating termination analyzer matches one of three
non-halting behavior patterns
(a) Simple Infinite loop
(b) Simple Infinite Recursion
(c) Simple Recursive Simulation
It aborts it simulation and reports that the input specifies
a non-halting sequence of configurations. Otherwise it continues
to simulate the input to completion. Non-terminating inputs that
have complex non-halting behaviors are outside of its domain.

"Simulating termination analyzer" probably just means halt decider.  We
all know there's no such thing.
 

The difference is that as long as a STA gets one input that halts correctly and one input that fails to halt correctly then it is a
STA. An actual halt decider is required to be ALL knowing.

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

 

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