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.

I don't think an abort decider can be fooled by a pathological input.

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

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
therefore not responding is better than responding with a wrong answer.
So, both halves are wrong, but the half that aborts is more wrong. It
gives the wrong answer. The other half is also wrong, but it does not
give a wrong answer, but does not respond.

>
> I don't think an abort decider can be fooled by a pathological input.
>
I am very sorry to hear that.

On 2024-03-24 04:55:38 +0000, olcott said:

> 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.
>
> I don't think an abort decider can be fooled by a pathological input.

First you must determine whther you can define an abort decider.
Otherwise the subject quresition is not very meaningful.

Then you must find out whether any input is pathological. Note that
in this case the meaning of "pathological" is not the same as with
some other decider (it is metaphor, the literal meaning does not
apply).

Finally you need to find a proof of existence or non-existence of
a pathological input or a perfect decider.

--
Mikko

On 3/24/24 12:55 AM, olcott wrote:
> 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.
>
> I don't think an abort decider can be fooled by a pathological input.
>
>

Just because they are not in the set that was incorrect for one reason
doesn't make them correct.

That is just the fallacy of a False Dichotomy.

You are PRESUMING that a correct H must exsit, but it doesn't.

On 3/24/2024 5:07 AM, Mikko wrote:
> On 2024-03-24 04:55:38 +0000, olcott said:
>
>> 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.
>>
>> I don't think an abort decider can be fooled by a pathological input.
>
> First you must determine whther you can define an abort decider.
> Otherwise the subject quresition is not very meaningful.
>

(a) If simulating abort decider H correctly simulates its input D until
H correctly determines that its simulated D would never stop running
unless aborted then...

When I say something 500 times and people claim that I never said it
even once these people must be lying.

> Then you must find out whether any input is pathological. Note that
> in this case the meaning of "pathological" is not the same as with
> some other decider (it is metaphor, the literal meaning does not
> apply).
>
A pathological input is an input that calls its own decider.

> Finally you need to find a proof of existence or non-existence of
> a pathological input or a perfect decider.
>

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 }

When I say something 500 times and people claim that I never said it
even once these people must be lying.

A single counter-example would prove that no such perfect abort decider
can possibly exist. So far everyone dodges this question and tries to
get away with saying that an abort decider cannot ever decide the above
case.

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.

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

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. Exactly what are you software engineering skills? I have been
a professional C++ software engineer since Y2K.

> therefore not responding is better than responding with a wrong answer.
> So, both halves are wrong, but the half that aborts is more wrong. It
> gives the wrong answer. The other half is also wrong, but it does not
> give a wrong answer, but does not respond.
>
>>
>> I don't think an abort decider can be fooled by a pathological input.
>>
> I am very sorry to hear that.
>
>

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

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.

>
>> therefore not responding is better than responding with a wrong
>> answer. So, both halves are wrong, but the half that aborts is more
>> wrong. It gives the wrong answer. The other half is also wrong, but it
>> does not give a wrong answer, but does not respond.
>>
>>>
>>> I don't think an abort decider can be fooled by a pathological input.
>>>
>> I am very sorry to hear that.
>>
>>
>

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)

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

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

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

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?

On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
> 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).
>

I am estimating that you must be fibbing about your programming skill.
The D simulated by any implementation of H (that aborts or does not
abort its simulation) shown above cannot possibly reach its own line 04
also shown above.

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

On 3/25/24 11:17 AM, olcott wrote:
> 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. Exactly what are you software engineering skills? I have been
> a professional C++ software engineer since Y2K.

NEWBIE.

I've been paid to produce software since 1975. (and programming as a
hobby before that)

I have also studied some Computation Theory and have pointed out the
errors in those two "software engineers with master degrees in computar
science" arguements based on DEFINITION in Computation Theory, that I
suspect they never actually studied.

>
>> therefore not responding is better than responding with a wrong
>> answer. So, both halves are wrong, but the half that aborts is more
>> wrong. It gives the wrong answer. The other half is also wrong, but it
>> does not give a wrong answer, but does not respond.
>>
>>>
>>> I don't think an abort decider can be fooled by a pathological input.
>>>
>> I am very sorry to hear that.
>>
>>
>

On 3/25/24 1:33 PM, olcott wrote:
> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>> 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).
>>
>
> I am estimating that you must be fibbing about your programming skill.
> The D simulated by any implementation of H (that aborts or does not
> abort its simulation) shown above cannot possibly reach its own line 04
> also shown above.
>

But that isn't the question.

The question is does that machine described by the input Halt when run,
or, alternatively, does its correct simulation (not just by H) run
forever (and thus needs to be aborted)?

Correct simulation refering to a simulation of the EXACT input given to
H, that calls the H that you claim to be giving the correct answer (and
not the "correct simulator")

On 3/25/2024 6:47 PM, Richard Damon wrote:
> On 3/25/24 1:33 PM, olcott wrote:
>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>> 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).
>>>
>>
>> I am estimating that you must be fibbing about your programming skill.
>> The D simulated by any implementation of H (that aborts or does not
>> abort its simulation) shown above cannot possibly reach its own line 04
>> also shown above.
>>
>
> But that isn't the question.
>

*That <is> the abort decision question*

> The question is does that machine described by the input Halt when run,
> or, alternatively, does its correct simulation (not just by H) run
> forever (and thus needs to be aborted)?
>

Since you know that H(D,D) must abort its simulation to prevent its
own infinite execution I don't understand why you would lie about it.

I really want to get on to the next step and see if any input can
fool an abort decider into making the wrong abort decision.

Perhaps you already know that you are not up to this challenge?

> Correct simulation refering to a simulation of the EXACT input given to
> H, that calls the H that you claim to be giving the correct answer (and
> not the "correct simulator")

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

On 3/25/24 8:11 PM, olcott wrote:
> On 3/25/2024 6:47 PM, Richard Damon wrote:
>> On 3/25/24 1:33 PM, olcott wrote:
>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>> 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).
>>>>
>>>
>>> I am estimating that you must be fibbing about your programming skill.
>>> The D simulated by any implementation of H (that aborts or does not
>>> abort its simulation) shown above cannot possibly reach its own line 04
>>> also shown above.
>>>
>>
>> But that isn't the question.
>>
>
> *That <is> the abort decision question*

But you agreed that a correct abort decider oly NEEDS to abort its
simulation if the correct simulation by a pure correct simulator of the
input given to H (which doesn't change, so for this case, still calls
that original H) will never reach a final state.

>
>> The question is does that machine described by the input Halt when
>> run, or, alternatively, does its correct simulation (not just by H)
>> run forever (and thus needs to be aborted)?
>>
>
> Since you know that H(D,D) must abort its simulation to prevent its
> own infinite execution I don't understand why you would lie about it.

But an H that doesn't abort and an H that does abort are looking at
different inputs "D", since you agree that the behavior of D changes
based on the H that it is using.

>
> I really want to get on to the next step and see if any input can
> fool an abort decider into making the wrong abort decision.

But you need to get this step right first.

>
> Perhaps you already know that you are not up to this challenge?

No, it seems that YOU are not up to it, as you can't seem to understand
the error that you are making.

You keep on lying to yourself about what your requirements are.

>
>> Correct simulation refering to a simulation of the EXACT input given
>> to H, that calls the H that you claim to be giving the correct answer
>> (and not the "correct simulator")
>

On 3/25/2024 7:22 PM, Richard Damon wrote:
> On 3/25/24 8:11 PM, olcott wrote:
>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>> On 3/25/24 1:33 PM, olcott wrote:
>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>> 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).
>>>>>
>>>>
>>>> I am estimating that you must be fibbing about your programming skill.
>>>> The D simulated by any implementation of H (that aborts or does not
>>>> abort its simulation) shown above cannot possibly reach its own line 04
>>>> also shown above.
>>>>
>>>
>>> But that isn't the question.
>>>
>>
>> *That <is> the abort decision question*
>
> But you agreed that a correct abort decider oly NEEDS to abort its
> simulation if the correct simulation by a pure correct simulator of the
> input given to H (which doesn't change, so for this case, still calls
> that original H) will never reach a final state.
>
>>
>>> The question is does that machine described by the input Halt when
>>> run, or, alternatively, does its correct simulation (not just by H)
>>> run forever (and thus needs to be aborted)?
>>>
>>
>> Since you know that H(D,D) must abort its simulation to prevent its
>> own infinite execution I don't understand why you would lie about it.
>
> But an H that doesn't abort and an H that does abort are looking at
> different inputs "D", since you agree that the behavior of D changes
> based on the H that it is using.
>

Not at all. Of the infinite set of every possible implementation of
H where H(D,D) simulates its input everyone that chose to abort is
necessarily correct.

I don't understand why you persist in lying about this.

>>
>> I really want to get on to the next step and see if any input can
>> fool an abort decider into making the wrong abort decision.
>
> But you need to get this step right first.
>
>>
>> Perhaps you already know that you are not up to this challenge?
>
> No, it seems that YOU are not up to it, as you can't seem to understand
> the error that you are making.
>
> You keep on lying to yourself about what your requirements are.
>

I am not the one that keeps using the strawman deception to change
the subject away from H(D,D) an abort decider for the above D.

>>
>>> Correct simulation refering to a simulation of the EXACT input given
>>> to H, that calls the H that you claim to be giving the correct answer
>>> (and not the "correct simulator")
>>
>

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

On 3/25/24 8:37 PM, olcott wrote:
> On 3/25/2024 7:22 PM, Richard Damon wrote:
>> On 3/25/24 8:11 PM, olcott wrote:
>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>> 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).
>>>>>>
>>>>>
>>>>> I am estimating that you must be fibbing about your programming skill.
>>>>> The D simulated by any implementation of H (that aborts or does not
>>>>> abort its simulation) shown above cannot possibly reach its own
>>>>> line 04
>>>>> also shown above.
>>>>>
>>>>
>>>> But that isn't the question.
>>>>
>>>
>>> *That <is> the abort decision question*
>>
>> But you agreed that a correct abort decider oly NEEDS to abort its
>> simulation if the correct simulation by a pure correct simulator of
>> the input given to H (which doesn't change, so for this case, still
>> calls that original H) will never reach a final state.
>>
>>>
>>>> The question is does that machine described by the input Halt when
>>>> run, or, alternatively, does its correct simulation (not just by H)
>>>> run forever (and thus needs to be aborted)?
>>>>
>>>
>>> Since you know that H(D,D) must abort its simulation to prevent its
>>> own infinite execution I don't understand why you would lie about it.
>>
>> But an H that doesn't abort and an H that does abort are looking at
>> different inputs "D", since you agree that the behavior of D changes
>> based on the H that it is using.
>>
>
> Not at all. Of the infinite set of every possible implementation of
> H where H(D,D) simulates its input everyone that chose to abort is
> necessarily correct.
>
> I don't understand why you persist in lying about this.
>
>>>
>>> I really want to get on to the next step and see if any input can
>>> fool an abort decider into making the wrong abort decision.
>>
>> But you need to get this step right first.
>>
>>>
>>> Perhaps you already know that you are not up to this challenge?
>>
>> No, it seems that YOU are not up to it, as you can't seem to
>> understand the error that you are making.
>>
>> You keep on lying to yourself about what your requirements are.
>>
>
> I am not the one that keeps using the strawman deception to change
> the subject away from H(D,D) an abort decider for the above D.

Neither am I.

YOU agreed that the criteria for an abort decider is only CORRECT if a
CORRECT simulation of the exact input given to H(D,D) (i.e UTM(D,D) )
does not halt, where D still calls that H(D,D)

>
>>>
>>>> Correct simulation refering to a simulation of the EXACT input given
>>>> to H, that calls the H that you claim to be giving the correct
>>>> answer (and not the "correct simulator")
>>>
>>
>

On 3/25/2024 7:47 PM, Richard Damon wrote:
> On 3/25/24 8:37 PM, olcott wrote:
>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>> On 3/25/24 8:11 PM, olcott wrote:
>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>> 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).
>>>>>>>
>>>>>>
>>>>>> I am estimating that you must be fibbing about your programming
>>>>>> skill.
>>>>>> The D simulated by any implementation of H (that aborts or does not
>>>>>> abort its simulation) shown above cannot possibly reach its own
>>>>>> line 04
>>>>>> also shown above.
>>>>>>
>>>>>
>>>>> But that isn't the question.
>>>>>
>>>>
>>>> *That <is> the abort decision question*
>>>
>>> But you agreed that a correct abort decider oly NEEDS to abort its
>>> simulation if the correct simulation by a pure correct simulator of
>>> the input given to H (which doesn't change, so for this case, still
>>> calls that original H) will never reach a final state.
>>>
>>>>
>>>>> The question is does that machine described by the input Halt when
>>>>> run, or, alternatively, does its correct simulation (not just by H)
>>>>> run forever (and thus needs to be aborted)?
>>>>>
>>>>
>>>> Since you know that H(D,D) must abort its simulation to prevent its
>>>> own infinite execution I don't understand why you would lie about it.
>>>
>>> But an H that doesn't abort and an H that does abort are looking at
>>> different inputs "D", since you agree that the behavior of D changes
>>> based on the H that it is using.
>>>
>>
>> Not at all. Of the infinite set of every possible implementation of
>> H where H(D,D) simulates its input everyone that chose to abort is
>> necessarily correct.
>>
>> I don't understand why you persist in lying about this.
>>
>>>>
>>>> I really want to get on to the next step and see if any input can
>>>> fool an abort decider into making the wrong abort decision.
>>>
>>> But you need to get this step right first.
>>>
>>>>
>>>> Perhaps you already know that you are not up to this challenge?
>>>
>>> No, it seems that YOU are not up to it, as you can't seem to
>>> understand the error that you are making.
>>>
>>> You keep on lying to yourself about what your requirements are.
>>>
>>
>> I am not the one that keeps using the strawman deception to change
>> the subject away from H(D,D) an abort decider for the above D.
>
> Neither am I.
>
> YOU agreed that the criteria for an abort decider is only CORRECT if a
> CORRECT simulation of the exact input given to H(D,D) (i.e UTM(D,D) )
> does not halt, where D still calls that H(D,D)
>

I never agreed to that.

>
>>
>>>>
>>>>> Correct simulation refering to a simulation of the EXACT input
>>>>> given to H, that calls the H that you claim to be giving the
>>>>> correct answer (and not the "correct simulator")
>>>>
>>>
>>
>

On 3/25/24 9:12 PM, olcott wrote:
> On 3/25/2024 7:47 PM, Richard Damon wrote:
>> On 3/25/24 8:37 PM, olcott wrote:
>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>> 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).
>>>>>>>>
>>>>>>>
>>>>>>> I am estimating that you must be fibbing about your programming
>>>>>>> skill.
>>>>>>> The D simulated by any implementation of H (that aborts or does not
>>>>>>> abort its simulation) shown above cannot possibly reach its own
>>>>>>> line 04
>>>>>>> also shown above.
>>>>>>>
>>>>>>
>>>>>> But that isn't the question.
>>>>>>
>>>>>
>>>>> *That <is> the abort decision question*
>>>>
>>>> But you agreed that a correct abort decider oly NEEDS to abort its
>>>> simulation if the correct simulation by a pure correct simulator of
>>>> the input given to H (which doesn't change, so for this case, still
>>>> calls that original H) will never reach a final state.
>>>>
>>>>>
>>>>>> The question is does that machine described by the input Halt when
>>>>>> run, or, alternatively, does its correct simulation (not just by
>>>>>> H) run forever (and thus needs to be aborted)?
>>>>>>
>>>>>
>>>>> Since you know that H(D,D) must abort its simulation to prevent its
>>>>> own infinite execution I don't understand why you would lie about it.
>>>>
>>>> But an H that doesn't abort and an H that does abort are looking at
>>>> different inputs "D", since you agree that the behavior of D changes
>>>> based on the H that it is using.
>>>>
>>>
>>> Not at all. Of the infinite set of every possible implementation of
>>> H where H(D,D) simulates its input everyone that chose to abort is
>>> necessarily correct.
>>>
>>> I don't understand why you persist in lying about this.
>>>
>>>>>
>>>>> I really want to get on to the next step and see if any input can
>>>>> fool an abort decider into making the wrong abort decision.
>>>>
>>>> But you need to get this step right first.
>>>>
>>>>>
>>>>> Perhaps you already know that you are not up to this challenge?
>>>>
>>>> No, it seems that YOU are not up to it, as you can't seem to
>>>> understand the error that you are making.
>>>>
>>>> You keep on lying to yourself about what your requirements are.
>>>>
>>>
>>> I am not the one that keeps using the strawman deception to change
>>> the subject away from H(D,D) an abort decider for the above D.
>>
>> Neither am I.
>>
>> YOU agreed that the criteria for an abort decider is only CORRECT if a
>> CORRECT simulation of the exact input given to H(D,D) (i.e UTM(D,D) )
>> does not halt, where D still calls that H(D,D)
>>
>
> I never agreed to that.

On 3/25/2024 8:30 PM, Richard Damon wrote:
> On 3/25/24 9:12 PM, olcott wrote:
>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>> On 3/25/24 8:37 PM, olcott wrote:
>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>> 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).
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am estimating that you must be fibbing about your programming
>>>>>>>> skill.
>>>>>>>> The D simulated by any implementation of H (that aborts or does not
>>>>>>>> abort its simulation) shown above cannot possibly reach its own
>>>>>>>> line 04
>>>>>>>> also shown above.
>>>>>>>>
>>>>>>>
>>>>>>> But that isn't the question.
>>>>>>>
>>>>>>
>>>>>> *That <is> the abort decision question*
>>>>>
>>>>> But you agreed that a correct abort decider oly NEEDS to abort its
>>>>> simulation if the correct simulation by a pure correct simulator of
>>>>> the input given to H (which doesn't change, so for this case, still
>>>>> calls that original H) will never reach a final state.
>>>>>
>>>>>>
>>>>>>> The question is does that machine described by the input Halt
>>>>>>> when run, or, alternatively, does its correct simulation (not
>>>>>>> just by H) run forever (and thus needs to be aborted)?
>>>>>>>
>>>>>>
>>>>>> Since you know that H(D,D) must abort its simulation to prevent its
>>>>>> own infinite execution I don't understand why you would lie about it.
>>>>>
>>>>> But an H that doesn't abort and an H that does abort are looking at
>>>>> different inputs "D", since you agree that the behavior of D
>>>>> changes based on the H that it is using.
>>>>>
>>>>
>>>> Not at all. Of the infinite set of every possible implementation of
>>>> H where H(D,D) simulates its input everyone that chose to abort is
>>>> necessarily correct.
>>>>
>>>> I don't understand why you persist in lying about this.
>>>>
>>>>>>
>>>>>> I really want to get on to the next step and see if any input can
>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>
>>>>> But you need to get this step right first.
>>>>>
>>>>>>
>>>>>> Perhaps you already know that you are not up to this challenge?
>>>>>
>>>>> No, it seems that YOU are not up to it, as you can't seem to
>>>>> understand the error that you are making.
>>>>>
>>>>> You keep on lying to yourself about what your requirements are.
>>>>>
>>>>
>>>> I am not the one that keeps using the strawman deception to change
>>>> the subject away from H(D,D) an abort decider for the above D.
>>>
>>> Neither am I.
>>>
>>> YOU agreed that the criteria for an abort decider is only CORRECT if
>>> a CORRECT simulation of the exact input given to H(D,D) (i.e UTM(D,D)
>>> ) does not halt, where D still calls that H(D,D)
>>>
>>
>> I never agreed to that.
>
> Yes you did:
>
> On 3/17/24 6:11 AM, olcott wrote:
> > On 3/17/2024 12:22 AM, Richard Damon wrote:
> >> To me, for H to NEED to abort its simulation, that means that when
> giving the input to a correct simulator, that simulator will not halt.
> >>
> > Yes that is correct.
> >
>
> Since the ONLY definition of a "Correct Simulator" is a simulator that
> never aborts, you did..
>

On 3/25/24 9:35 PM, olcott wrote:
> On 3/25/2024 8:30 PM, Richard Damon wrote:
>> On 3/25/24 9:12 PM, olcott wrote:
>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>> 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).
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I am estimating that you must be fibbing about your programming
>>>>>>>>> skill.
>>>>>>>>> The D simulated by any implementation of H (that aborts or does
>>>>>>>>> not
>>>>>>>>> abort its simulation) shown above cannot possibly reach its own
>>>>>>>>> line 04
>>>>>>>>> also shown above.
>>>>>>>>>
>>>>>>>>
>>>>>>>> But that isn't the question.
>>>>>>>>
>>>>>>>
>>>>>>> *That <is> the abort decision question*
>>>>>>
>>>>>> But you agreed that a correct abort decider oly NEEDS to abort its
>>>>>> simulation if the correct simulation by a pure correct simulator
>>>>>> of the input given to H (which doesn't change, so for this case,
>>>>>> still calls that original H) will never reach a final state.
>>>>>>
>>>>>>>
>>>>>>>> The question is does that machine described by the input Halt
>>>>>>>> when run, or, alternatively, does its correct simulation (not
>>>>>>>> just by H) run forever (and thus needs to be aborted)?
>>>>>>>>
>>>>>>>
>>>>>>> Since you know that H(D,D) must abort its simulation to prevent its
>>>>>>> own infinite execution I don't understand why you would lie about
>>>>>>> it.
>>>>>>
>>>>>> But an H that doesn't abort and an H that does abort are looking
>>>>>> at different inputs "D", since you agree that the behavior of D
>>>>>> changes based on the H that it is using.
>>>>>>
>>>>>
>>>>> Not at all. Of the infinite set of every possible implementation of
>>>>> H where H(D,D) simulates its input everyone that chose to abort is
>>>>> necessarily correct.
>>>>>
>>>>> I don't understand why you persist in lying about this.
>>>>>
>>>>>>>
>>>>>>> I really want to get on to the next step and see if any input can
>>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>>
>>>>>> But you need to get this step right first.
>>>>>>
>>>>>>>
>>>>>>> Perhaps you already know that you are not up to this challenge?
>>>>>>
>>>>>> No, it seems that YOU are not up to it, as you can't seem to
>>>>>> understand the error that you are making.
>>>>>>
>>>>>> You keep on lying to yourself about what your requirements are.
>>>>>>
>>>>>
>>>>> I am not the one that keeps using the strawman deception to change
>>>>> the subject away from H(D,D) an abort decider for the above D.
>>>>
>>>> Neither am I.
>>>>
>>>> YOU agreed that the criteria for an abort decider is only CORRECT if
>>>> a CORRECT simulation of the exact input given to H(D,D) (i.e
>>>> UTM(D,D) ) does not halt, where D still calls that H(D,D)
>>>>
>>>
>>> I never agreed to that.
>>
>> Yes you did:
>>
>> On 3/17/24 6:11 AM, olcott wrote:
>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>  >> To me, for H to NEED to abort its simulation, that means that when
>> giving the input to a correct simulator, that simulator will not halt.
>>  >>
>>  > Yes that is correct.
>>  >
>>
>> Since the ONLY definition of a "Correct Simulator" is a simulator that
>> never aborts, you did..
>>
>
> Because we have been over this hundreds of times you know that I mean
> that a correct simulator means that every step that H simulates was
> correctly simulated, so why are you lying about this now?
>
> Are you trying to run out the clock on my rebuttals?
>

On 3/25/2024 9:08 PM, Richard Damon wrote:
> On 3/25/24 9:35 PM, olcott wrote:
>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>> On 3/25/24 9:12 PM, olcott wrote:
>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>> 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).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>> programming skill.
>>>>>>>>>> The D simulated by any implementation of H (that aborts or
>>>>>>>>>> does not
>>>>>>>>>> abort its simulation) shown above cannot possibly reach its
>>>>>>>>>> own line 04
>>>>>>>>>> also shown above.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But that isn't the question.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *That <is> the abort decision question*
>>>>>>>
>>>>>>> But you agreed that a correct abort decider oly NEEDS to abort
>>>>>>> its simulation if the correct simulation by a pure correct
>>>>>>> simulator of the input given to H (which doesn't change, so for
>>>>>>> this case, still calls that original H) will never reach a final
>>>>>>> state.
>>>>>>>
>>>>>>>>
>>>>>>>>> The question is does that machine described by the input Halt
>>>>>>>>> when run, or, alternatively, does its correct simulation (not
>>>>>>>>> just by H) run forever (and thus needs to be aborted)?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Since you know that H(D,D) must abort its simulation to prevent its
>>>>>>>> own infinite execution I don't understand why you would lie
>>>>>>>> about it.
>>>>>>>
>>>>>>> But an H that doesn't abort and an H that does abort are looking
>>>>>>> at different inputs "D", since you agree that the behavior of D
>>>>>>> changes based on the H that it is using.
>>>>>>>
>>>>>>
>>>>>> Not at all. Of the infinite set of every possible implementation of
>>>>>> H where H(D,D) simulates its input everyone that chose to abort is
>>>>>> necessarily correct.
>>>>>>
>>>>>> I don't understand why you persist in lying about this.
>>>>>>
>>>>>>>>
>>>>>>>> I really want to get on to the next step and see if any input can
>>>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>>>
>>>>>>> But you need to get this step right first.
>>>>>>>
>>>>>>>>
>>>>>>>> Perhaps you already know that you are not up to this challenge?
>>>>>>>
>>>>>>> No, it seems that YOU are not up to it, as you can't seem to
>>>>>>> understand the error that you are making.
>>>>>>>
>>>>>>> You keep on lying to yourself about what your requirements are.
>>>>>>>
>>>>>>
>>>>>> I am not the one that keeps using the strawman deception to change
>>>>>> the subject away from H(D,D) an abort decider for the above D.
>>>>>
>>>>> Neither am I.
>>>>>
>>>>> YOU agreed that the criteria for an abort decider is only CORRECT
>>>>> if a CORRECT simulation of the exact input given to H(D,D) (i.e
>>>>> UTM(D,D) ) does not halt, where D still calls that H(D,D)
>>>>>
>>>>
>>>> I never agreed to that.
>>>
>>> Yes you did:

On 3/25/24 10:53 PM, olcott wrote:
> On 3/25/2024 9:08 PM, Richard Damon wrote:
>> On 3/25/24 9:35 PM, olcott wrote:
>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> 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).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>> programming skill.
>>>>>>>>>>> The D simulated by any implementation of H (that aborts or
>>>>>>>>>>> does not
>>>>>>>>>>> abort its simulation) shown above cannot possibly reach its
>>>>>>>>>>> own line 04
>>>>>>>>>>> also shown above.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But that isn't the question.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>
>>>>>>>> But you agreed that a correct abort decider oly NEEDS to abort
>>>>>>>> its simulation if the correct simulation by a pure correct
>>>>>>>> simulator of the input given to H (which doesn't change, so for
>>>>>>>> this case, still calls that original H) will never reach a final
>>>>>>>> state.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> The question is does that machine described by the input Halt
>>>>>>>>>> when run, or, alternatively, does its correct simulation (not
>>>>>>>>>> just by H) run forever (and thus needs to be aborted)?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Since you know that H(D,D) must abort its simulation to prevent
>>>>>>>>> its
>>>>>>>>> own infinite execution I don't understand why you would lie
>>>>>>>>> about it.
>>>>>>>>
>>>>>>>> But an H that doesn't abort and an H that does abort are looking
>>>>>>>> at different inputs "D", since you agree that the behavior of D
>>>>>>>> changes based on the H that it is using.
>>>>>>>>
>>>>>>>
>>>>>>> Not at all. Of the infinite set of every possible implementation of
>>>>>>> H where H(D,D) simulates its input everyone that chose to abort is
>>>>>>> necessarily correct.
>>>>>>>
>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>
>>>>>>>>>
>>>>>>>>> I really want to get on to the next step and see if any input can
>>>>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>>>>
>>>>>>>> But you need to get this step right first.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Perhaps you already know that you are not up to this challenge?
>>>>>>>>
>>>>>>>> No, it seems that YOU are not up to it, as you can't seem to
>>>>>>>> understand the error that you are making.
>>>>>>>>
>>>>>>>> You keep on lying to yourself about what your requirements are.
>>>>>>>>
>>>>>>>
>>>>>>> I am not the one that keeps using the strawman deception to change
>>>>>>> the subject away from H(D,D) an abort decider for the above D.
>>>>>>
>>>>>> Neither am I.
>>>>>>
>>>>>> YOU agreed that the criteria for an abort decider is only CORRECT
>>>>>> if a CORRECT simulation of the exact input given to H(D,D) (i.e
>>>>>> UTM(D,D) ) does not halt, where D still calls that H(D,D)
>>>>>>
>>>>>
>>>>> I never agreed to that.
>>>>
>>>> Yes you did:
>
> *You just admitted to lying abut this* (see below).

On 3/25/2024 10:01 PM, Richard Damon wrote:
> On 3/25/24 10:53 PM, olcott wrote:
>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>> On 3/25/24 9:35 PM, olcott wrote:
>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>> 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).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>>> programming skill.
>>>>>>>>>>>> The D simulated by any implementation of H (that aborts or
>>>>>>>>>>>> does not
>>>>>>>>>>>> abort its simulation) shown above cannot possibly reach its
>>>>>>>>>>>> own line 04
>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>
>>>>>>>>> But you agreed that a correct abort decider oly NEEDS to abort
>>>>>>>>> its simulation if the correct simulation by a pure correct
>>>>>>>>> simulator of the input given to H (which doesn't change, so for
>>>>>>>>> this case, still calls that original H) will never reach a
>>>>>>>>> final state.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> The question is does that machine described by the input Halt
>>>>>>>>>>> when run, or, alternatively, does its correct simulation (not
>>>>>>>>>>> just by H) run forever (and thus needs to be aborted)?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Since you know that H(D,D) must abort its simulation to
>>>>>>>>>> prevent its
>>>>>>>>>> own infinite execution I don't understand why you would lie
>>>>>>>>>> about it.
>>>>>>>>>
>>>>>>>>> But an H that doesn't abort and an H that does abort are
>>>>>>>>> looking at different inputs "D", since you agree that the
>>>>>>>>> behavior of D changes based on the H that it is using.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Not at all. Of the infinite set of every possible implementation of
>>>>>>>> H where H(D,D) simulates its input everyone that chose to abort is
>>>>>>>> necessarily correct.
>>>>>>>>
>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I really want to get on to the next step and see if any input can
>>>>>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>>>>>
>>>>>>>>> But you need to get this step right first.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Perhaps you already know that you are not up to this challenge?
>>>>>>>>>
>>>>>>>>> No, it seems that YOU are not up to it, as you can't seem to
>>>>>>>>> understand the error that you are making.
>>>>>>>>>
>>>>>>>>> You keep on lying to yourself about what your requirements are.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am not the one that keeps using the strawman deception to change
>>>>>>>> the subject away from H(D,D) an abort decider for the above D.
>>>>>>>
>>>>>>> Neither am I.
>>>>>>>
>>>>>>> YOU agreed that the criteria for an abort decider is only CORRECT
>>>>>>> if a CORRECT simulation of the exact input given to H(D,D) (i.e
>>>>>>> UTM(D,D) ) does not halt, where D still calls that H(D,D)
>>>>>>>
>>>>>>
>>>>>> I never agreed to that.
>>>>>
>>>>> Yes you did:
>>
>> *You just admitted to lying abut this* (see below).
>
> Nope, see below.
>
>>
>>>>>
>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>  >> To me, for H to NEED to abort its simulation, that means that
>>>>> when giving the input to a correct simulator, that simulator will
>>>>> not halt.
>>>>>  >>
>>>>>  > Yes that is correct.
>>>>>  >
>>>>>
>>>>> Since the ONLY definition of a "Correct Simulator" is a simulator
>>>>> that never aborts, you did..
>>>>>
>>>>
>>>> Because we have been over this hundreds of times you know that I mean
>>>> that a correct simulator means that every step that H simulates was
>>>> correctly simulated, so why are you lying about this now?
>>>>
>>>> Are you trying to run out the clock on my rebuttals?
>>>>
>>>
>>> And YOU know that when *I* say "Correct Simulation", I mean per the
>>> definition of a UTM that exactly duplicates the full behavior of the
>>> input machine, and you agreed to ME.
>>>
>>
>> Then you are admitting that you lied when you claimed that
>> I believed that.
>
> YOU agreed with what *I* said. When I speak, words mean what *I* hold
> them to beleive.
>

Op 25.mrt.2024 om 18:33 schreef olcott:
> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>> 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).
>>
>
> I am estimating that you must be fibbing about your programming skill.
> The D simulated by any implementation of H (that aborts or does not
> abort its simulation) shown above cannot possibly reach its own line 04
> also shown above.

Even beginners see that for the H we are talking about, that aborts and
returns false, the only reason that D does not reach line 04 is that it
is aborted. So, the abortion was premature and incorrect. The correct
simulation of D halts (unless aborted).

On 3/25/24 11:29 PM, olcott wrote:
> On 3/25/2024 10:01 PM, Richard Damon wrote:
>> On 3/25/24 10:53 PM, olcott wrote:
>>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>>> On 3/25/24 9:35 PM, olcott wrote:
>>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> 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).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>> The D simulated by any implementation of H (that aborts or
>>>>>>>>>>>>> does not
>>>>>>>>>>>>> abort its simulation) shown above cannot possibly reach its
>>>>>>>>>>>>> own line 04
>>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>>
>>>>>>>>>> But you agreed that a correct abort decider oly NEEDS to abort
>>>>>>>>>> its simulation if the correct simulation by a pure correct
>>>>>>>>>> simulator of the input given to H (which doesn't change, so
>>>>>>>>>> for this case, still calls that original H) will never reach a
>>>>>>>>>> final state.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> The question is does that machine described by the input
>>>>>>>>>>>> Halt when run, or, alternatively, does its correct
>>>>>>>>>>>> simulation (not just by H) run forever (and thus needs to be
>>>>>>>>>>>> aborted)?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Since you know that H(D,D) must abort its simulation to
>>>>>>>>>>> prevent its
>>>>>>>>>>> own infinite execution I don't understand why you would lie
>>>>>>>>>>> about it.
>>>>>>>>>>
>>>>>>>>>> But an H that doesn't abort and an H that does abort are
>>>>>>>>>> looking at different inputs "D", since you agree that the
>>>>>>>>>> behavior of D changes based on the H that it is using.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Not at all. Of the infinite set of every possible
>>>>>>>>> implementation of
>>>>>>>>> H where H(D,D) simulates its input everyone that chose to abort is
>>>>>>>>> necessarily correct.
>>>>>>>>>
>>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I really want to get on to the next step and see if any input
>>>>>>>>>>> can
>>>>>>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>>>>>>
>>>>>>>>>> But you need to get this step right first.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Perhaps you already know that you are not up to this challenge?
>>>>>>>>>>
>>>>>>>>>> No, it seems that YOU are not up to it, as you can't seem to
>>>>>>>>>> understand the error that you are making.
>>>>>>>>>>
>>>>>>>>>> You keep on lying to yourself about what your requirements are.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I am not the one that keeps using the strawman deception to change
>>>>>>>>> the subject away from H(D,D) an abort decider for the above D.
>>>>>>>>
>>>>>>>> Neither am I.
>>>>>>>>
>>>>>>>> YOU agreed that the criteria for an abort decider is only
>>>>>>>> CORRECT if a CORRECT simulation of the exact input given to
>>>>>>>> H(D,D) (i.e UTM(D,D) ) does not halt, where D still calls that
>>>>>>>> H(D,D)
>>>>>>>>
>>>>>>>
>>>>>>> I never agreed to that.
>>>>>>
>>>>>> Yes you did:
>>>
>>> *You just admitted to lying abut this* (see below).
>>
>> Nope, see below.
>>
>>>
>>>>>>
>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>  >> To me, for H to NEED to abort its simulation, that means that
>>>>>> when giving the input to a correct simulator, that simulator will
>>>>>> not halt.
>>>>>>  >>
>>>>>>  > Yes that is correct.
>>>>>>  >
>>>>>>
>>>>>> Since the ONLY definition of a "Correct Simulator" is a simulator
>>>>>> that never aborts, you did..
>>>>>>
>>>>>
>>>>> Because we have been over this hundreds of times you know that I mean
>>>>> that a correct simulator means that every step that H simulates was
>>>>> correctly simulated, so why are you lying about this now?
>>>>>
>>>>> Are you trying to run out the clock on my rebuttals?
>>>>>
>>>>
>>>> And YOU know that when *I* say "Correct Simulation", I mean per the
>>>> definition of a UTM that exactly duplicates the full behavior of the
>>>> input machine, and you agreed to ME.
>>>>
>>>
>>> Then you are admitting that you lied when you claimed that
>>> I believed that.
>>
>> YOU agreed with what *I* said. When I speak, words mean what *I* hold
>> them to beleive.
>>
>
> Are you really willing to bet your soul on that?