Re: Can D simulated by H terminate normally?

On 5/3/24 7:55 AM, olcott wrote:

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?
 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);
}
 void Infinite_Loop()
{
   HERE: goto HERE;
}
 int factorial(int n)
{
   if (n >= 1)
     return n*factorial(n-1);
   else
     return 1;
}
 Can D correctly simulated by H terminate normally?
00 int H(ptr x, ptr x)  // ptr is pointer to int function
01 int D(ptr x)
02 {
03   int Halt_Status = H(x, x);
04   if (Halt_Status)
05     HERE: goto HERE;
06   return Halt_Status;
07 }
08
09 void main()
10 {
11   H(D,D);
12 }
 *Execution Trace*
Line 11: main() invokes H(D,D) that Simulates D(D) at Line 01
 *keeps repeating* (unless aborted)
Line 01
Line 02
Line 03: simulated D(D) invokes simulated H(D,D)
that simulates D(D) at Line 01
 *Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.
 I would think that a bright high school student would be
able to tell that D(D) simulated by H cannot possibly
reach past its own line 3. Four experts in C did say this.
 It does not make sense to me that this is actually too
difficult for people that come to this group.
 

exceot I have described TWO DIFFERENT methods of design for Hs that make this claim false.
The fact that you continue to repeat it shows you are not actually interested in a honest discussion, but are just tryiing to hammer people into blindly accepting your false claims (like rump does).
Even an average middle schooler should be able to understand my arguments and see how you are wrong, so I guess you aren't smarter than a 6th grader.