Re: Can D simulated by H terminate normally?

On 5/5/24 1:43 PM, olcott wrote:

On 5/5/2024 12:07 PM, joes wrote:

Am Sun, 05 May 2024 09:38:48 -0500 schrieb olcott:
>

On 5/5/2024 3:14 AM, Mikko wrote:

On 2024-05-04 13:56:27 +0000, olcott said:
>

On 5/4/2024 4:47 AM, Mikko wrote:

On 2024-05-03 11:55:15 +0000, olcott said:
>

On 5/3/2024 4:33 AM, Mikko wrote:

On 2024-05-02 18:35:19 +0000, olcott said:
>

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

olcott <polcott333@gmail.com> wrote:

On 4/30/2024 5:46 PM, Richard Damon wrote:

On 4/30/24 12:15 PM, olcott wrote:

On 4/30/2024 10:44 AM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 4/30/2024 3:46 AM, Fred. Zwarts wrote:

Op 29.apr.2024 om 21:04 schreef olcott:

>

When we add the brand new idea of {simulating termination
analyzer} to the existing idea of TM's then we must be careful
how we define halting otherwise every infinite loop will be
construed as halting.

>

Why?

>

That doesn't mean the machine reached a final state.

>

Alan seems to believe that a final state is whatever state that
an aborted simulation ends up in.

>
Only through your twisted reasoning.  For your information, I
hold to the standard definition of final state, i.e. one which
has no state following it.  An aborted simulation is in some
state, and that state is a final one, since there is none
following it.
>

On 4/30/2024 10:44 AM, Alan Mackenzie wrote:

You are thus mistaken in believing "abnormal" termination isn't
a final state.

>

Only if you try to define something that is NOT related to
Halting, do you get into that issue.

>

"The all new ideas are wrong" assessment.
Simulating termination analyzers <are> related to halting.

>
Except you cannot define what such a thing is, and that
relationship is anything but clear.

>
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

>
Simple recursive simulation is not a non-halting behaviour if the
recursion is not infinite.

>
In other words the only way that we can tell that an infinite loop
never halts is to simulate it until the end of time?

>
The phrase "in other words" is not correct here as it means that what
follows means the same as what precedes, and that is not true here.
>
For same loops the only wha to detect non-termination may be to
simulate to infinity but they can be considered exluded by the term
"simple" in (a).
>

There are repeating state non-halting behavior patterns that can be
recognized. These are three more functions where H derives the
correct halt status:
>
void Infinite_Recursion(u32 N)
{
    Infinite_Recursion(N);
}

>
Per (b) that is non-halting and indeed it is (though the execution
may crash for "out of memeory").
>

It is not actually infinite though because H recognizes the
non-halting behavior pattern, aborts the simulation and reports
non-halting.

>
The recursion is infinite. The simulation by H is incomplete and
finite.
>

Do you understand that it is ridiculously stupid for a simulating
termination analyzer to simulate a non-terminating input forever?

That’s the point. Either it simulates until a possibly nonexistent
termination, or it aborts and is thus not a simulator.
>

 So in other words you choose to simply "not believe in"
a simulating termination analyzer without being able to
show that it does not work correctly.

The onus of proof is on you.
Since D(D) Halts, H(D,D) can't say non-halting and be correct as a Halt Decider.
IF you want to try to REALLY define what a simulating termination analyzer means that is something actually useful and has a real meaning, try to make that definition.
So far, I haven't see you actually try to define this as an actual definition instead of trying to define by example.

 

It is the exact same thing with D simulated by H on the basis of the
directly executed H(D,D).
>

void Infinite_Loop()
{
    HERE: goto HERE;
}

>
Per (a) that is non-halting and indeed it is.

>
It is not actually infinite though because H recognizes the
non-halting behavior pattern, aborts the simulation and reports
non-halting.

>
The loop is infinite. The simulation by H is incomplete and finite.
>

Do you understand that it is ridiculously stupid for a simulating
termination analyzer to simulate a non-terminating input forever?

>
If H aborts, THE SAME H that D calls also does, thus D terminates, so
H was wrong in aborting. That’s exactly the proof.
>

 My new post is more clear on these things
[Every D(D) simulated by H presents non-halting behavior to H]
 *This new post proves this conclusion*
 From this we can definitely know that every D(D) of the infinite set of
H/D pairs where this D(D) is simulated by the H that this D(D) calls
that this D(D) presents non-halting behavior to this H.