Re: Can an abort decider be defined that cannot be fooled by any pathological input?

Op 25.mrt.2024 om 17:04 schreef olcott:

On 3/25/2024 10:48 AM, Fred. Zwarts wrote:

Op 25.mrt.2024 om 16:17 schreef olcott:

On 3/24/2024 3:51 AM, Fred. Zwarts wrote:

Op 24.mrt.2024 om 05:55 schreef olcott:

Can an abort decider be defined that cannot be fooled by any pathological input?
>
01 int D(ptr x)  // ptr is pointer to int function
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 }
>
Of all of the elements of the set of H(D,D) where H simulates its
input there are matched pairs of otherwise identical elements that
only differ by whether they abort their simulation or not.
>
The half of these that don't abort are incorrect because all deciders
must halt. This makes the other half correct about the abort/no abort
decision.

>
No. The other, aborting, half is just wrong, because it aborts when it is not needed. So, the half that aborts is wrong and it may be argued that it is better to not abort something that halts on its own and that

>
At least two software engineers with masters degrees in computer science
disagree.

>
Two is not many, considering that with Google for any invalid idea it is easy to find a several people with a master degree supporting it.
>

Exactly what are you software engineering skills?

>
I have been professionally programming since 1986 in several languages. (Non professionally I started programming in 1975). Since about 1990 I programmed in C and since about 2000 in C++.
>
>

I have been a professional C++ software engineer since Y2K.

>
I'm sorry to hear that olcott has been so smart, but now he does not even sees what even a beginner sees.

 Can D correctly simulated by H terminate normally?
01 int D(ptr x)  // ptr is pointer to int function
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);
 *keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Even a beginner sees that, if the H that aborts is chosen, simulated H(D,D) aborts and returns false (unless aborted). So simulated D halts (unless aborted).

 *Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.

Even a beginner will admit that a correct simulating decider would see that D would go to line 04, then line 06 and then halt (unless aborted).
The only reason D does not reach past line 03 is that it is aborted, otherwise it would.

 *The subject matter is THE D simulated by any H as specified above*
*Try and point put any mistake without using the strawman deception*
>

When will olcott finally see his mistakes, which even beginners see?