On 3/23/24 10:04 PM, olcott wrote:
> On 3/23/2024 7:27 PM, Richard Damon wrote:
>> On 3/23/24 6:22 PM, olcott wrote:
>>> On 3/23/2024 4:06 PM, Richard Damon wrote:
>>>> On 3/23/24 4:26 PM, olcott wrote:
>>>>> On 3/23/2024 3:18 PM, Richard Damon wrote:
>>>>>> On 3/23/24 3:48 PM, olcott wrote:
>>>>>>> On 3/23/2024 2:42 PM, Fred. Zwarts wrote:
>>>>>>>> Op 23.mrt.2024 om 20:26 schreef olcott:
>>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort
>>>>>>>>>>>>>>>> and return false, then [the simulated] D will
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> As can be seen above, if H returns false in line 03, then
>>>>>>>>>>>>>> D will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>>
>>>>>>>>>>>> Even a beginner in C will see that if the simulated D, using
>>>>>>>>>>>> the H that is programmed to abort and return false, will
>>>>>>>>>>>> continue with line 04 then line 06 and halt (unless aborted).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> 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 }
>>>>>>>>>>>
>>>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>>
>>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>>>>> possibly
>>>>>>>>>>>>> return to its caller. The relationship between the
>>>>>>>>>>>>> simulated D(D)
>>>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>>>> isomorphic
>>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>>
>>>>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>>>>> which makes that also the simulated H is programmed to abort
>>>>>>>>>>>> and return false.
>>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>>>> instance
>>>>>>>>>>>>> that does not have this same pathological relationship is
>>>>>>>>>>>>> summed
>>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>>
>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>> simulated D!
>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>> simulated D!
>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>
>>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>>
>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>>>> programming skill.
>>>>>>>>>>>
>>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>>> beginner sees, that H, programmed to return false, also
>>>>>>>>>>>> returns false when simulated (unless aborted).
>>>>>>>>>>>
>>>>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>>>>> programs that they reviewed and they reviewed all of the
>>>>>>>>>>> programs.
>>>>>>>>>>
>>>>>>>>>> If true, I am very sorry for olcott, that he is no longer able
>>>>>>>>>> to see, what even a beginner sees, that H, programmed to
>>>>>>>>>> return false, also returns false when simulated (unless aborted).
>>>>>>>>>
>>>>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>>>>> verified fact:
>>>>>>>>>
>>>>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>>>>> state*
>>>>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>>>>> Some of these people might lie about it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Even a beginner can see that this is a verified fact:
>>>>>>>> H, programmed to return false,
>>>>>>>
>>>>>>> H is not programmed to return false. H is programmed
>>>>>>> to detect and reject non-halting behavior patterns:
>>>>>>> (a) Infinite loop
>>>>>>> (b) Infinite recursion
>>>>>>> (c) Recursive simulation
>>>>>>
>>>>>> So, then why does it return false?
>>>>>>
>>>>>> It seems to not do what you programmed it to do
>>>>>>
>>>>>>>
>>>>>>>> also returns false when simulated (unless aborted), so D, when
>>>>>>>> correctly simulated, halts (unless aborted).
>>>>>>>
>>>>>>> Of every implementation of H that is merely specified to simulate
>>>>>>> its input and no other details of H are specified: No D simulated
>>>>>>> by H ever reaches its own final state at line 06 and halts.
>>>>>>>
>>>>>>
>>>>>> But this instance of D isn't using any of those Hs. so that is an
>>>>>> irreleent fact.
>>>>>>
>>>>>> YOu are just proving you don't seem to know what you are doing.
>>>>>
>>>>> You are pretending to be too stupid to understand that when
>>>>> no D of an infinite set of H/D pairs halts that there may
>>>>> still be one D of this infinite set of H/D pairs that does halt.
>>>>>
>>>>> Trying to get away the strawman deception and refer to an H/D pair
>>>>> that is not in this set is lame.
>>>>>
>>>>
>>>> Since you H wasn't from the infinite set, neither was the D.
>>>>
>>>
>>> Of every implementation of H that is merely specified to simulate
>>> its input and no other details of H are specified:
>>>
>>> No D simulated by H ever reaches its own final state at line 06
>>> and halts.
>>>
>>>> After all, the infinite set of non-halting inputs was only Hs that
>>>> never abort.
>>>>
>>>
>>> WHETHER OR NOT H ABORTS ITS SIMULATION
>>> EVERY D SIMULATED BY H NEVER REACHES ITS FINAL STATE
>>> IN 1 TO ∞ STEPS OF CORRECT SIMULATION
>>>
>>> WHETHER OR NOT H ABORTS ITS SIMULATION
>>> EVERY D SIMULATED BY H NEVER REACHES ITS FINAL STATE
>>> IN 1 TO ∞ STEPS OF CORRECT SIMULATION
>>>
>>> WHETHER OR NOT H ABORTS ITS SIMULATION
>>> EVERY D SIMULATED BY H NEVER REACHES ITS FINAL STATE
>>> IN 1 TO ∞ STEPS OF CORRECT SIMULATION
>>>
>>> WHETHER OR NOT H ABORTS ITS SIMULATION
>>> EVERY D SIMULATED BY H NEVER REACHES ITS FINAL STATE
>>> IN 1 TO ∞ STEPS OF CORRECT SIMULATION
>>>
>>> WHETHER OR NOT H ABORTS ITS SIMULATION
>>> EVERY D SIMULATED BY H NEVER REACHES ITS FINAL STATE
>>> IN 1 TO ∞ STEPS OF CORRECT SIMULATION
>>>
>>>
>>
>> Nope. The CORRECT simulation of any D that H aborts and returns 0
>
> Your programming skills must be awful if you can't
> understand that this is true:
>
> WHETHER OR NOT H ABORTS ITS SIMULATION
> EVERY D SIMULATED BY H NEVER REACHES ITS FINAL STATE
> IN 1 TO ∞ STEPS OF CORRECT SIMULATION

On 3/23/2024 5:19 PM, immibis wrote:
> On 23/03/24 20:26, olcott wrote:
>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>
>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>
>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>> non-termination.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>
>>>>>>>> immediately stop running never having reached its last
>>>>>>>> instruction to halt.
>>>>>>>
>>>>>>> As can be seen above, if H returns false in line 03, then D will
>>>>>>> go to line 04 and line 06 and halt (unless aborted).
>>>>>>>
>>>>>>
>>>>>> You still do not understand that functions called in infinite
>>>>>> recursion never return to their caller, thus must have grossly
>>>>>> exaggerated your programming skill.
>>>>>
>>>>> Even a beginner in C will see that if the simulated D, using the H
>>>>> that is programmed to abort and return false, will continue with
>>>>> line 04 then line 06 and halt (unless aborted).
>>>>>
>>>>
>>>> 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 }
>>>>
>>>> That is the strawman deception we are only talking about the
>>>> fact that the D correctly simulated by H cannot possibly reach
>>>> its own line 06 and halt.
>>>
>>> Denying a verified fact is not a strong rebuttal.
>>>
>>>>
>>>>>> When the simulated D calls its simulator this call cannot possibly
>>>>>> return to its caller. The relationship between the simulated D(D)
>>>>>> and its simulator makes a call D(D) to its own simulator isomorphic
>>>>>> to infinite recursion.
>>>>>
>>>>> It is exactly the relation with the simulator that aborts, which
>>>>> makes that also the simulated H is programmed to abort and return
>>>>> false.
>>>>> Olcott is again contradicting himself.
>>>>>
>>>>>>
>>>>>> That the directly executed D(D) is an entirely different instance
>>>>>> that does not have this same pathological relationship is summed
>>>>>> up in your own reply.
>>>>>
>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>
>>>>> This simulated D halts (unless aborted)!
>>>>
>>>> D correctly simulated by H cannot possibly reach its own line
>>>> 06 and halt. That you say otherwise proves your insufficient
>>>> programming skill.
>>>>
>>>>> It seems too difficult for olcott to see, what even a beginner
>>>>> sees, that H, programmed to return false, also returns false when
>>>>> simulated (unless aborted).
>>>>
>>>> When I worked at the US Army Corps of engineers an independent
>>>> contractor rated my programs as the best quality of all of the
>>>> programs that they reviewed and they reviewed all of the programs.
>>>
>>> If true, I am very sorry for olcott, that he is no longer able to
>>> see, what even a beginner sees, that H, programmed to return false,
>>> also returns false when simulated (unless aborted).
>>
>> Everyone with sufficient programming skill can see that this is a
>> verified fact:
>>
>> *D correctly simulated by H cannot possibly reach its own final state*
>> *at line 06 in an infinite number of steps of correct simulation*
>> Some of these people might lie about it.
>>
>
> Everyone with sufficient programming skill can see that H is not defined
> as part of program D, and if you define H inside program D, then it
> might be possible to tell whether it reaches line 06 or not.

*It is stipulated that H must correctly simulate 1 to ∞ steps of D*
Every other detail about H is unspecified because it is irrelevant.

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/25/24 2:07 PM, olcott wrote:
> On 3/23/2024 5:19 PM, immibis wrote:
>> On 23/03/24 20:26, olcott wrote:
>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>> 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 }
>>>>>>>>>>>
>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>
>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>
>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>> non-termination.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>>
>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>> instruction to halt.
>>>>>>>>
>>>>>>>> As can be seen above, if H returns false in line 03, then D will
>>>>>>>> go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>
>>>>>>>
>>>>>>> You still do not understand that functions called in infinite
>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>> exaggerated your programming skill.
>>>>>>
>>>>>> Even a beginner in C will see that if the simulated D, using the H
>>>>>> that is programmed to abort and return false, will continue with
>>>>>> line 04 then line 06 and halt (unless aborted).
>>>>>>
>>>>>
>>>>> 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 }
>>>>>
>>>>> That is the strawman deception we are only talking about the
>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>> its own line 06 and halt.
>>>>
>>>> Denying a verified fact is not a strong rebuttal.
>>>>
>>>>>
>>>>>>> When the simulated D calls its simulator this call cannot possibly
>>>>>>> return to its caller. The relationship between the simulated D(D)
>>>>>>> and its simulator makes a call D(D) to its own simulator isomorphic
>>>>>>> to infinite recursion.
>>>>>>
>>>>>> It is exactly the relation with the simulator that aborts, which
>>>>>> makes that also the simulated H is programmed to abort and return
>>>>>> false.
>>>>>> Olcott is again contradicting himself.
>>>>>>
>>>>>>>
>>>>>>> That the directly executed D(D) is an entirely different instance
>>>>>>> that does not have this same pathological relationship is summed
>>>>>>> up in your own reply.
>>>>>>
>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>
>>>>>> This simulated D halts (unless aborted)!
>>>>>
>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>> programming skill.
>>>>>
>>>>>> It seems too difficult for olcott to see, what even a beginner
>>>>>> sees, that H, programmed to return false, also returns false when
>>>>>> simulated (unless aborted).
>>>>>
>>>>> When I worked at the US Army Corps of engineers an independent
>>>>> contractor rated my programs as the best quality of all of the
>>>>> programs that they reviewed and they reviewed all of the programs.
>>>>
>>>> If true, I am very sorry for olcott, that he is no longer able to
>>>> see, what even a beginner sees, that H, programmed to return false,
>>>> also returns false when simulated (unless aborted).
>>>
>>> Everyone with sufficient programming skill can see that this is a
>>> verified fact:
>>>
>>> *D correctly simulated by H cannot possibly reach its own final state*
>>> *at line 06 in an infinite number of steps of correct simulation*
>>> Some of these people might lie about it.
>>>
>>
>> Everyone with sufficient programming skill can see that H is not
>> defined as part of program D, and if you define H inside program D,
>> then it might be possible to tell whether it reaches line 06 or not.
>
> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
> Every other detail about H is unspecified because it is irrelevant.

Then your stipulation is just ILLOGICAL, as a given H can only do one thing.

Garbage In, Garbage Out, and proof is shown to come from an unsound mine.

>
> 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.

Which are DIFFERENGT.

I guess you are just claiming that we can consider a cat to be a 10
story office building.

>
> 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.
>
>
Nope, proves you to be a pathological lying idiot.

On 3/25/2024 6:44 PM, Richard Damon wrote:
> On 3/25/24 2:07 PM, olcott wrote:
>> On 3/23/2024 5:19 PM, immibis wrote:
>>> On 23/03/24 20:26, olcott wrote:
>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>> 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 }
>>>>>>>>>>>>
>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>
>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>
>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>>>
>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>> instruction to halt.
>>>>>>>>>
>>>>>>>>> As can be seen above, if H returns false in line 03, then D
>>>>>>>>> will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>
>>>>>>>>
>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>> exaggerated your programming skill.
>>>>>>>
>>>>>>> Even a beginner in C will see that if the simulated D, using the
>>>>>>> H that is programmed to abort and return false, will continue
>>>>>>> with line 04 then line 06 and halt (unless aborted).
>>>>>>>
>>>>>>
>>>>>> 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 }
>>>>>>
>>>>>> That is the strawman deception we are only talking about the
>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>> its own line 06 and halt.
>>>>>
>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>
>>>>>>
>>>>>>>> When the simulated D calls its simulator this call cannot possibly
>>>>>>>> return to its caller. The relationship between the simulated D(D)
>>>>>>>> and its simulator makes a call D(D) to its own simulator isomorphic
>>>>>>>> to infinite recursion.
>>>>>>>
>>>>>>> It is exactly the relation with the simulator that aborts, which
>>>>>>> makes that also the simulated H is programmed to abort and return
>>>>>>> false.
>>>>>>> Olcott is again contradicting himself.
>>>>>>>
>>>>>>>>
>>>>>>>> That the directly executed D(D) is an entirely different instance
>>>>>>>> that does not have this same pathological relationship is summed
>>>>>>>> up in your own reply.
>>>>>>>
>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>
>>>>>>> This simulated D halts (unless aborted)!
>>>>>>
>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>> programming skill.
>>>>>>
>>>>>>> It seems too difficult for olcott to see, what even a beginner
>>>>>>> sees, that H, programmed to return false, also returns false when
>>>>>>> simulated (unless aborted).
>>>>>>
>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>> contractor rated my programs as the best quality of all of the
>>>>>> programs that they reviewed and they reviewed all of the programs.
>>>>>
>>>>> If true, I am very sorry for olcott, that he is no longer able to
>>>>> see, what even a beginner sees, that H, programmed to return false,
>>>>> also returns false when simulated (unless aborted).
>>>>
>>>> Everyone with sufficient programming skill can see that this is a
>>>> verified fact:
>>>>
>>>> *D correctly simulated by H cannot possibly reach its own final state*
>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>> Some of these people might lie about it.
>>>>
>>>
>>> Everyone with sufficient programming skill can see that H is not
>>> defined as part of program D, and if you define H inside program D,
>>> then it might be possible to tell whether it reaches line 06 or not.
>>
>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>> Every other detail about H is unspecified because it is irrelevant.
>
>
> Then your stipulation is just ILLOGICAL, as a given H can only do one
> thing.

None-the-less they all share the common property that they either
run forever or abort the simulation of their input. All of the other
differences don't make and damn difference at all.

--
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:22 PM, olcott wrote:
> On 3/25/2024 6:44 PM, Richard Damon wrote:
>> On 3/25/24 2:07 PM, olcott wrote:
>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>> On 23/03/24 20:26, olcott wrote:
>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>
>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>>>>
>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>> instruction to halt.
>>>>>>>>>>
>>>>>>>>>> As can be seen above, if H returns false in line 03, then D
>>>>>>>>>> will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>>> exaggerated your programming skill.
>>>>>>>>
>>>>>>>> Even a beginner in C will see that if the simulated D, using the
>>>>>>>> H that is programmed to abort and return false, will continue
>>>>>>>> with line 04 then line 06 and halt (unless aborted).
>>>>>>>>
>>>>>>>
>>>>>>> 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 }
>>>>>>>
>>>>>>> That is the strawman deception we are only talking about the
>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>> its own line 06 and halt.
>>>>>>
>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>
>>>>>>>
>>>>>>>>> When the simulated D calls its simulator this call cannot possibly
>>>>>>>>> return to its caller. The relationship between the simulated D(D)
>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>> isomorphic
>>>>>>>>> to infinite recursion.
>>>>>>>>
>>>>>>>> It is exactly the relation with the simulator that aborts, which
>>>>>>>> makes that also the simulated H is programmed to abort and
>>>>>>>> return false.
>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> That the directly executed D(D) is an entirely different instance
>>>>>>>>> that does not have this same pathological relationship is summed
>>>>>>>>> up in your own reply.
>>>>>>>>
>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>
>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>
>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>> programming skill.
>>>>>>>
>>>>>>>> It seems too difficult for olcott to see, what even a beginner
>>>>>>>> sees, that H, programmed to return false, also returns false
>>>>>>>> when simulated (unless aborted).
>>>>>>>
>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>> programs that they reviewed and they reviewed all of the programs.
>>>>>>
>>>>>> If true, I am very sorry for olcott, that he is no longer able to
>>>>>> see, what even a beginner sees, that H, programmed to return
>>>>>> false, also returns false when simulated (unless aborted).
>>>>>
>>>>> Everyone with sufficient programming skill can see that this is a
>>>>> verified fact:
>>>>>
>>>>> *D correctly simulated by H cannot possibly reach its own final state*
>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>> Some of these people might lie about it.
>>>>>
>>>>
>>>> Everyone with sufficient programming skill can see that H is not
>>>> defined as part of program D, and if you define H inside program D,
>>>> then it might be possible to tell whether it reaches line 06 or not.
>>>
>>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>>> Every other detail about H is unspecified because it is irrelevant.
>>
>>
>> Then your stipulation is just ILLOGICAL, as a given H can only do one
>> thing.
>
> None-the-less they all share the common property that they either
> run forever or abort the simulation of their input. All of the other
> differences don't make and damn difference at all.
>

But that isn't a simple property, so you are creating a FALSE DICHOTOMY.

All the ones that fail to abort have Ds that are based on that and these
become non-halting, and thus, these should have aborted to answer (but
didn't)

On 3/25/2024 7:31 PM, Richard Damon wrote:
> On 3/25/24 8:22 PM, olcott wrote:
>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>> On 3/25/24 2:07 PM, olcott wrote:
>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>>>>>
>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>
>>>>>>>>>>> As can be seen above, if H returns false in line 03, then D
>>>>>>>>>>> will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>
>>>>>>>>> Even a beginner in C will see that if the simulated D, using
>>>>>>>>> the H that is programmed to abort and return false, will
>>>>>>>>> continue with line 04 then line 06 and halt (unless aborted).
>>>>>>>>>
>>>>>>>>
>>>>>>>> 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 }
>>>>>>>>
>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>> its own line 06 and halt.
>>>>>>>
>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>
>>>>>>>>
>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>> possibly
>>>>>>>>>> return to its caller. The relationship between the simulated D(D)
>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>> isomorphic
>>>>>>>>>> to infinite recursion.
>>>>>>>>>
>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>> which makes that also the simulated H is programmed to abort
>>>>>>>>> and return false.
>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> That the directly executed D(D) is an entirely different instance
>>>>>>>>>> that does not have this same pathological relationship is summed
>>>>>>>>>> up in your own reply.
>>>>>>>>>
>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>
>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>
>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>> programming skill.
>>>>>>>>
>>>>>>>>> It seems too difficult for olcott to see, what even a beginner
>>>>>>>>> sees, that H, programmed to return false, also returns false
>>>>>>>>> when simulated (unless aborted).
>>>>>>>>
>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>> programs that they reviewed and they reviewed all of the programs.
>>>>>>>
>>>>>>> If true, I am very sorry for olcott, that he is no longer able to
>>>>>>> see, what even a beginner sees, that H, programmed to return
>>>>>>> false, also returns false when simulated (unless aborted).
>>>>>>
>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>> verified fact:
>>>>>>
>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>> state*
>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>> Some of these people might lie about it.
>>>>>>
>>>>>
>>>>> Everyone with sufficient programming skill can see that H is not
>>>>> defined as part of program D, and if you define H inside program D,
>>>>> then it might be possible to tell whether it reaches line 06 or not.
>>>>
>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>>>> Every other detail about H is unspecified because it is irrelevant.
>>>
>>>
>>> Then your stipulation is just ILLOGICAL, as a given H can only do one
>>> thing.
>>
>> None-the-less they all share the common property that they either
>> run forever or abort the simulation of their input. All of the other
>> differences don't make and damn difference at all.
>>
>
> But that isn't a simple property, so you are creating a FALSE DICHOTOMY.
>
> All the ones that fail to abort

On 3/25/24 8:44 PM, olcott wrote:
> On 3/25/2024 7:31 PM, Richard Damon wrote:
>> On 3/25/24 8:22 PM, olcott wrote:
>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>>>>>>
>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>
>>>>>>>>>>>> As can be seen above, if H returns false in line 03, then D
>>>>>>>>>>>> will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>
>>>>>>>>>> Even a beginner in C will see that if the simulated D, using
>>>>>>>>>> the H that is programmed to abort and return false, will
>>>>>>>>>> continue with line 04 then line 06 and halt (unless aborted).
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 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 }
>>>>>>>>>
>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>>> its own line 06 and halt.
>>>>>>>>
>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>>> possibly
>>>>>>>>>>> return to its caller. The relationship between the simulated
>>>>>>>>>>> D(D)
>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>> isomorphic
>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>
>>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>>> which makes that also the simulated H is programmed to abort
>>>>>>>>>> and return false.
>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>> instance
>>>>>>>>>>> that does not have this same pathological relationship is summed
>>>>>>>>>>> up in your own reply.
>>>>>>>>>>
>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>
>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>
>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>> programming skill.
>>>>>>>>>
>>>>>>>>>> It seems too difficult for olcott to see, what even a beginner
>>>>>>>>>> sees, that H, programmed to return false, also returns false
>>>>>>>>>> when simulated (unless aborted).
>>>>>>>>>
>>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>>> programs that they reviewed and they reviewed all of the programs.
>>>>>>>>
>>>>>>>> If true, I am very sorry for olcott, that he is no longer able
>>>>>>>> to see, what even a beginner sees, that H, programmed to return
>>>>>>>> false, also returns false when simulated (unless aborted).
>>>>>>>
>>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>>> verified fact:
>>>>>>>
>>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>>> state*
>>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>>> Some of these people might lie about it.
>>>>>>>
>>>>>>
>>>>>> Everyone with sufficient programming skill can see that H is not
>>>>>> defined as part of program D, and if you define H inside program
>>>>>> D, then it might be possible to tell whether it reaches line 06 or
>>>>>> not.
>>>>>
>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>>>>> Every other detail about H is unspecified because it is irrelevant.
>>>>
>>>>
>>>> Then your stipulation is just ILLOGICAL, as a given H can only do
>>>> one thing.
>>>
>>> None-the-less they all share the common property that they either
>>> run forever or abort the simulation of their input. All of the other
>>> differences don't make and damn difference at all.
>>>
>>
>> But that isn't a simple property, so you are creating a FALSE DICHOTOMY.
>>
>> All the ones that fail to abort
>
> Are in the set that fail to abort, [set(a)]
> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>
> Instead of the deceptive names of the individual members we can
> call them set (a) and set (b).

On 3/25/2024 7:55 PM, Richard Damon wrote:
> On 3/25/24 8:44 PM, olcott wrote:
>> On 3/25/2024 7:31 PM, Richard Damon wrote:
>>> On 3/25/24 8:22 PM, olcott wrote:
>>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> As can be seen above, if H returns false in line 03, then D
>>>>>>>>>>>>> will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>
>>>>>>>>>>> Even a beginner in C will see that if the simulated D, using
>>>>>>>>>>> the H that is programmed to abort and return false, will
>>>>>>>>>>> continue with line 04 then line 06 and halt (unless aborted).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>
>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>>>> possibly
>>>>>>>>>>>> return to its caller. The relationship between the simulated
>>>>>>>>>>>> D(D)
>>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>>> isomorphic
>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>
>>>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>>>> which makes that also the simulated H is programmed to abort
>>>>>>>>>>> and return false.
>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>>> instance
>>>>>>>>>>>> that does not have this same pathological relationship is
>>>>>>>>>>>> summed
>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>
>>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>>
>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>
>>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>>> programming skill.
>>>>>>>>>>
>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>> beginner sees, that H, programmed to return false, also
>>>>>>>>>>> returns false when simulated (unless aborted).
>>>>>>>>>>
>>>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>>>> programs that they reviewed and they reviewed all of the
>>>>>>>>>> programs.
>>>>>>>>>
>>>>>>>>> If true, I am very sorry for olcott, that he is no longer able
>>>>>>>>> to see, what even a beginner sees, that H, programmed to return
>>>>>>>>> false, also returns false when simulated (unless aborted).
>>>>>>>>
>>>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>>>> verified fact:
>>>>>>>>
>>>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>>>> state*
>>>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>>>> Some of these people might lie about it.
>>>>>>>>
>>>>>>>
>>>>>>> Everyone with sufficient programming skill can see that H is not
>>>>>>> defined as part of program D, and if you define H inside program
>>>>>>> D, then it might be possible to tell whether it reaches line 06
>>>>>>> or not.
>>>>>>
>>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>>>>>> Every other detail about H is unspecified because it is irrelevant.
>>>>>
>>>>>
>>>>> Then your stipulation is just ILLOGICAL, as a given H can only do
>>>>> one thing.
>>>>
>>>> None-the-less they all share the common property that they either
>>>> run forever or abort the simulation of their input. All of the other
>>>> differences don't make and damn difference at all.
>>>>
>>>
>>> But that isn't a simple property, so you are creating a FALSE DICHOTOMY.
>>>
>>> All the ones that fail to abort
>>
>> Are in the set that fail to abort, [set(a)]
>> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>>
>> Instead of the deceptive names of the individual members we can
>> call them set (a) and set (b).
>
> Fine, and you have shown that we needed to abort all of the simulations
> of D built on an H in set (a).
>
> That DOESN'T meen that it was correct to abort the simulation of any of
> the Ds built from an H from set (b).
>

On 3/25/24 9:28 PM, olcott wrote:
> On 3/25/2024 7:55 PM, Richard Damon wrote:
>> On 3/25/24 8:44 PM, olcott wrote:
>>> On 3/25/2024 7:31 PM, Richard Damon wrote:
>>>> On 3/25/24 8:22 PM, olcott wrote:
>>>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort
>>>>>>>>>>>>>>>> and return false, then [the simulated] D will
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> As can be seen above, if H returns false in line 03, then
>>>>>>>>>>>>>> D will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>>
>>>>>>>>>>>> Even a beginner in C will see that if the simulated D, using
>>>>>>>>>>>> the H that is programmed to abort and return false, will
>>>>>>>>>>>> continue with line 04 then line 06 and halt (unless aborted).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> 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 }
>>>>>>>>>>>
>>>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>>
>>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>>>>> possibly
>>>>>>>>>>>>> return to its caller. The relationship between the
>>>>>>>>>>>>> simulated D(D)
>>>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>>>> isomorphic
>>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>>
>>>>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>>>>> which makes that also the simulated H is programmed to abort
>>>>>>>>>>>> and return false.
>>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>>>> instance
>>>>>>>>>>>>> that does not have this same pathological relationship is
>>>>>>>>>>>>> summed
>>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>>
>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>> simulated D!
>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>> simulated D!
>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>
>>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>>
>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>>>> programming skill.
>>>>>>>>>>>
>>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>>> beginner sees, that H, programmed to return false, also
>>>>>>>>>>>> returns false when simulated (unless aborted).
>>>>>>>>>>>
>>>>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>>>>> programs that they reviewed and they reviewed all of the
>>>>>>>>>>> programs.
>>>>>>>>>>
>>>>>>>>>> If true, I am very sorry for olcott, that he is no longer able
>>>>>>>>>> to see, what even a beginner sees, that H, programmed to
>>>>>>>>>> return false, also returns false when simulated (unless aborted).
>>>>>>>>>
>>>>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>>>>> verified fact:
>>>>>>>>>
>>>>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>>>>> state*
>>>>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>>>>> Some of these people might lie about it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Everyone with sufficient programming skill can see that H is not
>>>>>>>> defined as part of program D, and if you define H inside program
>>>>>>>> D, then it might be possible to tell whether it reaches line 06
>>>>>>>> or not.
>>>>>>>
>>>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>>>>>>> Every other detail about H is unspecified because it is irrelevant.
>>>>>>
>>>>>>
>>>>>> Then your stipulation is just ILLOGICAL, as a given H can only do
>>>>>> one thing.
>>>>>
>>>>> None-the-less they all share the common property that they either
>>>>> run forever or abort the simulation of their input. All of the other
>>>>> differences don't make and damn difference at all.
>>>>>
>>>>
>>>> But that isn't a simple property, so you are creating a FALSE
>>>> DICHOTOMY.
>>>>
>>>> All the ones that fail to abort
>>>
>>> Are in the set that fail to abort, [set(a)]
>>> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>>>
>>> Instead of the deceptive names of the individual members we can
>>> call them set (a) and set (b).
>>
>> Fine, and you have shown that we needed to abort all of the
>> simulations of D built on an H in set (a).
>>
>> That DOESN'T meen that it was correct to abort the simulation of any
>> of the Ds built from an H from set (b).
>>
>
> By definition every (a) is wrong and every (b) is correct.

On 3/25/2024 9:04 PM, Richard Damon wrote:
> On 3/25/24 9:28 PM, olcott wrote:
>> On 3/25/2024 7:55 PM, Richard Damon wrote:
>>> On 3/25/24 8:44 PM, olcott wrote:
>>>> On 3/25/2024 7:31 PM, Richard Damon wrote:
>>>>> On 3/25/24 8:22 PM, olcott wrote:
>>>>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort
>>>>>>>>>>>>>>>>> and return false, then [the simulated] D will
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> As can be seen above, if H returns false in line 03, then
>>>>>>>>>>>>>>> D will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>>>>>>> recursion never return to their caller, thus must have
>>>>>>>>>>>>>> grossly
>>>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Even a beginner in C will see that if the simulated D,
>>>>>>>>>>>>> using the H that is programmed to abort and return false,
>>>>>>>>>>>>> will continue with line 04 then line 06 and halt (unless
>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> 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 }
>>>>>>>>>>>>
>>>>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>>>
>>>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>>>>>> possibly
>>>>>>>>>>>>>> return to its caller. The relationship between the
>>>>>>>>>>>>>> simulated D(D)
>>>>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>>>>> isomorphic
>>>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>>>>>> which makes that also the simulated H is programmed to
>>>>>>>>>>>>> abort and return false.
>>>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>>>>> instance
>>>>>>>>>>>>>> that does not have this same pathological relationship is
>>>>>>>>>>>>>> summed
>>>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>
>>>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>>>
>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>
>>>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>>>> beginner sees, that H, programmed to return false, also
>>>>>>>>>>>>> returns false when simulated (unless aborted).
>>>>>>>>>>>>
>>>>>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>>>>>> programs that they reviewed and they reviewed all of the
>>>>>>>>>>>> programs.
>>>>>>>>>>>
>>>>>>>>>>> If true, I am very sorry for olcott, that he is no longer
>>>>>>>>>>> able to see, what even a beginner sees, that H, programmed to
>>>>>>>>>>> return false, also returns false when simulated (unless
>>>>>>>>>>> aborted).
>>>>>>>>>>
>>>>>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>>>>>> verified fact:
>>>>>>>>>>
>>>>>>>>>> *D correctly simulated by H cannot possibly reach its own
>>>>>>>>>> final state*
>>>>>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>>>>>> Some of these people might lie about it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Everyone with sufficient programming skill can see that H is
>>>>>>>>> not defined as part of program D, and if you define H inside
>>>>>>>>> program D, then it might be possible to tell whether it reaches
>>>>>>>>> line 06 or not.
>>>>>>>>
>>>>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>>>>>>>> Every other detail about H is unspecified because it is irrelevant.
>>>>>>>
>>>>>>>
>>>>>>> Then your stipulation is just ILLOGICAL, as a given H can only do
>>>>>>> one thing.
>>>>>>
>>>>>> None-the-less they all share the common property that they either
>>>>>> run forever or abort the simulation of their input. All of the other
>>>>>> differences don't make and damn difference at all.
>>>>>>
>>>>>
>>>>> But that isn't a simple property, so you are creating a FALSE
>>>>> DICHOTOMY.
>>>>>
>>>>> All the ones that fail to abort
>>>>
>>>> Are in the set that fail to abort, [set(a)]
>>>> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>>>>
>>>> Instead of the deceptive names of the individual members we can
>>>> call them set (a) and set (b).
>>>
>>> Fine, and you have shown that we needed to abort all of the
>>> simulations of D built on an H in set (a).
>>>
>>> That DOESN'T meen that it was correct to abort the simulation of any
>>> of the Ds built from an H from set (b).
>>>
>>
>> By definition every (a) is wrong and every (b) is correct.
>
> Then you need tp be "Stipulating" sucn a definition of "Correct" to
> include proven INCORRECT answwers and admit that you logic is based on
> lying.
>

On 3/25/24 10:19 PM, olcott wrote:
> On 3/25/2024 9:04 PM, Richard Damon wrote:
>> On 3/25/24 9:28 PM, olcott wrote:
>>> On 3/25/2024 7:55 PM, Richard Damon wrote:
>>>> On 3/25/24 8:44 PM, olcott wrote:
>>>>> On 3/25/2024 7:31 PM, Richard Damon wrote:
>>>>>> On 3/25/24 8:22 PM, olcott wrote:
>>>>>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>>>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort
>>>>>>>>>>>>>>>>>> and return false, then [the simulated] D will
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> As can be seen above, if H returns false in line 03,
>>>>>>>>>>>>>>>> then D will go to line 04 and line 06 and halt (unless
>>>>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You still do not understand that functions called in
>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>> recursion never return to their caller, thus must have
>>>>>>>>>>>>>>> grossly
>>>>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Even a beginner in C will see that if the simulated D,
>>>>>>>>>>>>>> using the H that is programmed to abort and return false,
>>>>>>>>>>>>>> will continue with line 04 then line 06 and halt (unless
>>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>>>>
>>>>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>>>>>>> possibly
>>>>>>>>>>>>>>> return to its caller. The relationship between the
>>>>>>>>>>>>>>> simulated D(D)
>>>>>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>>>>>> isomorphic
>>>>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>>>>>>> which makes that also the simulated H is programmed to
>>>>>>>>>>>>>> abort and return false.
>>>>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>>>>>> instance
>>>>>>>>>>>>>>> that does not have this same pathological relationship is
>>>>>>>>>>>>>>> summed
>>>>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>>>>
>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>>>>> beginner sees, that H, programmed to return false, also
>>>>>>>>>>>>>> returns false when simulated (unless aborted).
>>>>>>>>>>>>>
>>>>>>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>>>>>>> programs that they reviewed and they reviewed all of the
>>>>>>>>>>>>> programs.
>>>>>>>>>>>>
>>>>>>>>>>>> If true, I am very sorry for olcott, that he is no longer
>>>>>>>>>>>> able to see, what even a beginner sees, that H, programmed
>>>>>>>>>>>> to return false, also returns false when simulated (unless
>>>>>>>>>>>> aborted).
>>>>>>>>>>>
>>>>>>>>>>> Everyone with sufficient programming skill can see that this
>>>>>>>>>>> is a
>>>>>>>>>>> verified fact:
>>>>>>>>>>>
>>>>>>>>>>> *D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>> final state*
>>>>>>>>>>> *at line 06 in an infinite number of steps of correct
>>>>>>>>>>> simulation*
>>>>>>>>>>> Some of these people might lie about it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Everyone with sufficient programming skill can see that H is
>>>>>>>>>> not defined as part of program D, and if you define H inside
>>>>>>>>>> program D, then it might be possible to tell whether it
>>>>>>>>>> reaches line 06 or not.
>>>>>>>>>
>>>>>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps
>>>>>>>>> of D*
>>>>>>>>> Every other detail about H is unspecified because it is
>>>>>>>>> irrelevant.
>>>>>>>>
>>>>>>>>
>>>>>>>> Then your stipulation is just ILLOGICAL, as a given H can only
>>>>>>>> do one thing.
>>>>>>>
>>>>>>> None-the-less they all share the common property that they either
>>>>>>> run forever or abort the simulation of their input. All of the other
>>>>>>> differences don't make and damn difference at all.
>>>>>>>
>>>>>>
>>>>>> But that isn't a simple property, so you are creating a FALSE
>>>>>> DICHOTOMY.
>>>>>>
>>>>>> All the ones that fail to abort
>>>>>
>>>>> Are in the set that fail to abort, [set(a)]
>>>>> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>>>>>
>>>>> Instead of the deceptive names of the individual members we can
>>>>> call them set (a) and set (b).
>>>>
>>>> Fine, and you have shown that we needed to abort all of the
>>>> simulations of D built on an H in set (a).
>>>>
>>>> That DOESN'T meen that it was correct to abort the simulation of any
>>>> of the Ds built from an H from set (b).
>>>>
>>>
>>> By definition every (a) is wrong and every (b) is correct.
>>
>> Then you need tp be "Stipulating" sucn a definition of "Correct" to
>> include proven INCORRECT answwers and admit that you logic is based on
>> lying.
>>
>
> Try and clearly show how any element of (b) is incorrect
> using set theory.

On 3/25/2024 9:44 PM, Richard Damon wrote:
> On 3/25/24 10:19 PM, olcott wrote:
>> On 3/25/2024 9:04 PM, Richard Damon wrote:
>>> On 3/25/24 9:28 PM, olcott wrote:
>>>> On 3/25/2024 7:55 PM, Richard Damon wrote:
>>>>> On 3/25/24 8:44 PM, olcott wrote:
>>>>>> On 3/25/2024 7:31 PM, Richard Damon wrote:
>>>>>>> On 3/25/24 8:22 PM, olcott wrote:
>>>>>>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>>>>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>>>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort
>>>>>>>>>>>>>>>>>>> and return false, then [the simulated] D will
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> As can be seen above, if H returns false in line 03,
>>>>>>>>>>>>>>>>> then D will go to line 04 and line 06 and halt (unless
>>>>>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You still do not understand that functions called in
>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>> recursion never return to their caller, thus must have
>>>>>>>>>>>>>>>> grossly
>>>>>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Even a beginner in C will see that if the simulated D,
>>>>>>>>>>>>>>> using the H that is programmed to abort and return false,
>>>>>>>>>>>>>>> will continue with line 04 then line 06 and halt (unless
>>>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>>>>>>> fact that the D correctly simulated by H cannot possibly
>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When the simulated D calls its simulator this call
>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>> return to its caller. The relationship between the
>>>>>>>>>>>>>>>> simulated D(D)
>>>>>>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>>>>>>> isomorphic
>>>>>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is exactly the relation with the simulator that
>>>>>>>>>>>>>>> aborts, which makes that also the simulated H is
>>>>>>>>>>>>>>> programmed to abort and return false.
>>>>>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>>>>>>> instance
>>>>>>>>>>>>>>>> that does not have this same pathological relationship
>>>>>>>>>>>>>>>> is summed
>>>>>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>>>>>> beginner sees, that H, programmed to return false, also
>>>>>>>>>>>>>>> returns false when simulated (unless aborted).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When I worked at the US Army Corps of engineers an
>>>>>>>>>>>>>> independent
>>>>>>>>>>>>>> contractor rated my programs as the best quality of all of
>>>>>>>>>>>>>> the
>>>>>>>>>>>>>> programs that they reviewed and they reviewed all of the
>>>>>>>>>>>>>> programs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If true, I am very sorry for olcott, that he is no longer
>>>>>>>>>>>>> able to see, what even a beginner sees, that H, programmed
>>>>>>>>>>>>> to return false, also returns false when simulated (unless
>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>
>>>>>>>>>>>> Everyone with sufficient programming skill can see that this
>>>>>>>>>>>> is a
>>>>>>>>>>>> verified fact:
>>>>>>>>>>>>
>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>>> final state*
>>>>>>>>>>>> *at line 06 in an infinite number of steps of correct
>>>>>>>>>>>> simulation*
>>>>>>>>>>>> Some of these people might lie about it.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Everyone with sufficient programming skill can see that H is
>>>>>>>>>>> not defined as part of program D, and if you define H inside
>>>>>>>>>>> program D, then it might be possible to tell whether it
>>>>>>>>>>> reaches line 06 or not.
>>>>>>>>>>
>>>>>>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps
>>>>>>>>>> of D*
>>>>>>>>>> Every other detail about H is unspecified because it is
>>>>>>>>>> irrelevant.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Then your stipulation is just ILLOGICAL, as a given H can only
>>>>>>>>> do one thing.
>>>>>>>>
>>>>>>>> None-the-less they all share the common property that they either
>>>>>>>> run forever or abort the simulation of their input. All of the
>>>>>>>> other
>>>>>>>> differences don't make and damn difference at all.
>>>>>>>>
>>>>>>>
>>>>>>> But that isn't a simple property, so you are creating a FALSE
>>>>>>> DICHOTOMY.
>>>>>>>
>>>>>>> All the ones that fail to abort
>>>>>>
>>>>>> Are in the set that fail to abort, [set(a)]
>>>>>> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>>>>>>
>>>>>> Instead of the deceptive names of the individual members we can
>>>>>> call them set (a) and set (b).
>>>>>
>>>>> Fine, and you have shown that we needed to abort all of the
>>>>> simulations of D built on an H in set (a).
>>>>>
>>>>> That DOESN'T meen that it was correct to abort the simulation of
>>>>> any of the Ds built from an H from set (b).
>>>>>
>>>>
>>>> By definition every (a) is wrong and every (b) is correct.
>>>
>>> Then you need tp be "Stipulating" sucn a definition of "Correct" to
>>> include proven INCORRECT answwers and admit that you logic is based
>>> on lying.
>>>
>>
>> Try and clearly show how any element of (b) is incorrect
>> using set theory.
>
> Set theory doesn't have the tools to do it.
>
> You are just proving your stupidity.
>
>>
>>>
>>>>
>>>>>>
>>>>>> It is like you are trying to get away with claiming that
>>>>>> some of the living things THAT ARE ANIMALS ARE NOT ANIMALS
>>>>>> by referring to the subset of cats.
>>>>>>
>>>>>
>>>>> Nope, YOU are the one make claims about things that you can't
>>>>> actually show.
>>>>>
>>>>
>>>> *Let's try and formalize this more precisely with set theory*
>>>>
>>>> X are H/D pairs where H simulates D.
>>>> Y are the subset of X where H does not abort its simulation.
>>>> Z are the subset of X where H aborts its simulation.
>>>>
>>>> All X are Y xor Z
>>>> All Y are incorrect
>>>> All Z are correct
>>>>
>>>
>>>
>>> Why are all Z correct?
>>>
>>> Remember, D's behavior changes based on what H it is paired with.
>>>
>> It does not change in any relevant way.
>
> Of course it does.
>
> DO you considdr being Non-Halting vs Halting not a "relevent" fact?
>
> I guess you REALLY think cats can be 10 story office buildings.
>
>> Try and show how it changes in a relevant way.
>
> D(D) based on an H that never aborts its simulation of this input will
> be non-halting.
>
> D(D) based on an H that DOES abort its simulation simulation of this
> input, and returns non-halting will be halting.
>

On 3/25/24 10:57 PM, olcott wrote:
> On 3/25/2024 9:44 PM, Richard Damon wrote:
>> On 3/25/24 10:19 PM, olcott wrote:
>>> On 3/25/2024 9:04 PM, Richard Damon wrote:
>>>> On 3/25/24 9:28 PM, olcott wrote:
>>>>> On 3/25/2024 7:55 PM, Richard Damon wrote:
>>>>>> On 3/25/24 8:44 PM, olcott wrote:
>>>>>>> On 3/25/2024 7:31 PM, Richard Damon wrote:
>>>>>>>> On 3/25/24 8:22 PM, olcott wrote:
>>>>>>>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>>>>>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>>>>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>>>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is self-evident that when H is programmed to
>>>>>>>>>>>>>>>>>>>> abort and return false, then [the simulated] D will
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> immediately stop running never having reached its
>>>>>>>>>>>>>>>>>>> last instruction to halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> As can be seen above, if H returns false in line 03,
>>>>>>>>>>>>>>>>>> then D will go to line 04 and line 06 and halt (unless
>>>>>>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You still do not understand that functions called in
>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>> recursion never return to their caller, thus must have
>>>>>>>>>>>>>>>>> grossly
>>>>>>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Even a beginner in C will see that if the simulated D,
>>>>>>>>>>>>>>>> using the H that is programmed to abort and return
>>>>>>>>>>>>>>>> false, will continue with line 04 then line 06 and halt
>>>>>>>>>>>>>>>> (unless aborted).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>>>>>>>> fact that the D correctly simulated by H cannot possibly
>>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When the simulated D calls its simulator this call
>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>> return to its caller. The relationship between the
>>>>>>>>>>>>>>>>> simulated D(D)
>>>>>>>>>>>>>>>>> and its simulator makes a call D(D) to its own
>>>>>>>>>>>>>>>>> simulator isomorphic
>>>>>>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is exactly the relation with the simulator that
>>>>>>>>>>>>>>>> aborts, which makes that also the simulated H is
>>>>>>>>>>>>>>>> programmed to abort and return false.
>>>>>>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That the directly executed D(D) is an entirely
>>>>>>>>>>>>>>>>> different instance
>>>>>>>>>>>>>>>>> that does not have this same pathological relationship
>>>>>>>>>>>>>>>>> is summed
>>>>>>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>>>>>> line
>>>>>>>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>>>>>>> beginner sees, that H, programmed to return false, also
>>>>>>>>>>>>>>>> returns false when simulated (unless aborted).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When I worked at the US Army Corps of engineers an
>>>>>>>>>>>>>>> independent
>>>>>>>>>>>>>>> contractor rated my programs as the best quality of all
>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>> programs that they reviewed and they reviewed all of the
>>>>>>>>>>>>>>> programs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If true, I am very sorry for olcott, that he is no longer
>>>>>>>>>>>>>> able to see, what even a beginner sees, that H, programmed
>>>>>>>>>>>>>> to return false, also returns false when simulated (unless
>>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Everyone with sufficient programming skill can see that
>>>>>>>>>>>>> this is a
>>>>>>>>>>>>> verified fact:
>>>>>>>>>>>>>
>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>>>> final state*
>>>>>>>>>>>>> *at line 06 in an infinite number of steps of correct
>>>>>>>>>>>>> simulation*
>>>>>>>>>>>>> Some of these people might lie about it.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Everyone with sufficient programming skill can see that H is
>>>>>>>>>>>> not defined as part of program D, and if you define H inside
>>>>>>>>>>>> program D, then it might be possible to tell whether it
>>>>>>>>>>>> reaches line 06 or not.
>>>>>>>>>>>
>>>>>>>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps
>>>>>>>>>>> of D*
>>>>>>>>>>> Every other detail about H is unspecified because it is
>>>>>>>>>>> irrelevant.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then your stipulation is just ILLOGICAL, as a given H can only
>>>>>>>>>> do one thing.
>>>>>>>>>
>>>>>>>>> None-the-less they all share the common property that they either
>>>>>>>>> run forever or abort the simulation of their input. All of the
>>>>>>>>> other
>>>>>>>>> differences don't make and damn difference at all.
>>>>>>>>>
>>>>>>>>
>>>>>>>> But that isn't a simple property, so you are creating a FALSE
>>>>>>>> DICHOTOMY.
>>>>>>>>
>>>>>>>> All the ones that fail to abort
>>>>>>>
>>>>>>> Are in the set that fail to abort, [set(a)]
>>>>>>> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>>>>>>>
>>>>>>> Instead of the deceptive names of the individual members we can
>>>>>>> call them set (a) and set (b).
>>>>>>
>>>>>> Fine, and you have shown that we needed to abort all of the
>>>>>> simulations of D built on an H in set (a).
>>>>>>
>>>>>> That DOESN'T meen that it was correct to abort the simulation of
>>>>>> any of the Ds built from an H from set (b).
>>>>>>
>>>>>
>>>>> By definition every (a) is wrong and every (b) is correct.
>>>>
>>>> Then you need tp be "Stipulating" sucn a definition of "Correct" to
>>>> include proven INCORRECT answwers and admit that you logic is based
>>>> on lying.
>>>>
>>>
>>> Try and clearly show how any element of (b) is incorrect
>>> using set theory.
>>
>> Set theory doesn't have the tools to do it.
>>
>> You are just proving your stupidity.
>>
>>>
>>>>
>>>>>
>>>>>>>
>>>>>>> It is like you are trying to get away with claiming that
>>>>>>> some of the living things THAT ARE ANIMALS ARE NOT ANIMALS
>>>>>>> by referring to the subset of cats.
>>>>>>>
>>>>>>
>>>>>> Nope, YOU are the one make claims about things that you can't
>>>>>> actually show.
>>>>>>
>>>>>
>>>>> *Let's try and formalize this more precisely with set theory*
>>>>>
>>>>> X are H/D pairs where H simulates D.
>>>>> Y are the subset of X where H does not abort its simulation.
>>>>> Z are the subset of X where H aborts its simulation.
>>>>>
>>>>> All X are Y xor Z
>>>>> All Y are incorrect
>>>>> All Z are correct
>>>>>
>>>>
>>>>
>>>> Why are all Z correct?
>>>>
>>>> Remember, D's behavior changes based on what H it is paired with.
>>>>
>>> It does not change in any relevant way.
>>
>> Of course it does.
>>
>> DO you considdr being Non-Halting vs Halting not a "relevent" fact?
>>
>> I guess you REALLY think cats can be 10 story office buildings.
>>
>>> Try and show how it changes in a relevant way.
>>
>> D(D) based on an H that never aborts its simulation of this input will
>> be non-halting.
>>
>> D(D) based on an H that DOES abort its simulation simulation of this
>> input, and returns non-halting will be halting.
>>
>
> I am saying that H/D pairs where H simulates D that this D right here
> not some other D somewhere else never reaches its own line 06.

On 3/25/2024 10:06 PM, Richard Damon wrote:
> On 3/25/24 10:57 PM, olcott wrote:
>> On 3/25/2024 9:44 PM, Richard Damon wrote:
>>> On 3/25/24 10:19 PM, olcott wrote:
>>>> On 3/25/2024 9:04 PM, Richard Damon wrote:
>>>>> On 3/25/24 9:28 PM, olcott wrote:
>>>>>> On 3/25/2024 7:55 PM, Richard Damon wrote:
>>>>>>> On 3/25/24 8:44 PM, olcott wrote:
>>>>>>>> On 3/25/2024 7:31 PM, Richard Damon wrote:
>>>>>>>>> On 3/25/24 8:22 PM, olcott wrote:
>>>>>>>>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>>>>>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>>>>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is self-evident that when H is programmed to
>>>>>>>>>>>>>>>>>>>>> abort and return false, then [the simulated] D will
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> immediately stop running never having reached its
>>>>>>>>>>>>>>>>>>>> last instruction to halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> As can be seen above, if H returns false in line 03,
>>>>>>>>>>>>>>>>>>> then D will go to line 04 and line 06 and halt
>>>>>>>>>>>>>>>>>>> (unless aborted).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You still do not understand that functions called in
>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>> recursion never return to their caller, thus must have
>>>>>>>>>>>>>>>>>> grossly
>>>>>>>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Even a beginner in C will see that if the simulated D,
>>>>>>>>>>>>>>>>> using the H that is programmed to abort and return
>>>>>>>>>>>>>>>>> false, will continue with line 04 then line 06 and halt
>>>>>>>>>>>>>>>>> (unless aborted).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is the strawman deception we are only talking about
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> fact that the D correctly simulated by H cannot possibly
>>>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When the simulated D calls its simulator this call
>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>> return to its caller. The relationship between the
>>>>>>>>>>>>>>>>>> simulated D(D)
>>>>>>>>>>>>>>>>>> and its simulator makes a call D(D) to its own
>>>>>>>>>>>>>>>>>> simulator isomorphic
>>>>>>>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is exactly the relation with the simulator that
>>>>>>>>>>>>>>>>> aborts, which makes that also the simulated H is
>>>>>>>>>>>>>>>>> programmed to abort and return false.
>>>>>>>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That the directly executed D(D) is an entirely
>>>>>>>>>>>>>>>>>> different instance
>>>>>>>>>>>>>>>>>> that does not have this same pathological relationship
>>>>>>>>>>>>>>>>>> is summed
>>>>>>>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>>>>>>> line
>>>>>>>>>>>>>>>> 06 and halt. That you say otherwise proves your
>>>>>>>>>>>>>>>> insufficient
>>>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>>>>>>>> beginner sees, that H, programmed to return false, also
>>>>>>>>>>>>>>>>> returns false when simulated (unless aborted).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When I worked at the US Army Corps of engineers an
>>>>>>>>>>>>>>>> independent
>>>>>>>>>>>>>>>> contractor rated my programs as the best quality of all
>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>> programs that they reviewed and they reviewed all of the
>>>>>>>>>>>>>>>> programs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If true, I am very sorry for olcott, that he is no longer
>>>>>>>>>>>>>>> able to see, what even a beginner sees, that H,
>>>>>>>>>>>>>>> programmed to return false, also returns false when
>>>>>>>>>>>>>>> simulated (unless aborted).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Everyone with sufficient programming skill can see that
>>>>>>>>>>>>>> this is a
>>>>>>>>>>>>>> verified fact:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>>>>> final state*
>>>>>>>>>>>>>> *at line 06 in an infinite number of steps of correct
>>>>>>>>>>>>>> simulation*
>>>>>>>>>>>>>> Some of these people might lie about it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Everyone with sufficient programming skill can see that H
>>>>>>>>>>>>> is not defined as part of program D, and if you define H
>>>>>>>>>>>>> inside program D, then it might be possible to tell whether
>>>>>>>>>>>>> it reaches line 06 or not.
>>>>>>>>>>>>
>>>>>>>>>>>> *It is stipulated that H must correctly simulate 1 to ∞
>>>>>>>>>>>> steps of D*
>>>>>>>>>>>> Every other detail about H is unspecified because it is
>>>>>>>>>>>> irrelevant.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Then your stipulation is just ILLOGICAL, as a given H can
>>>>>>>>>>> only do one thing.
>>>>>>>>>>
>>>>>>>>>> None-the-less they all share the common property that they either
>>>>>>>>>> run forever or abort the simulation of their input. All of the
>>>>>>>>>> other
>>>>>>>>>> differences don't make and damn difference at all.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But that isn't a simple property, so you are creating a FALSE
>>>>>>>>> DICHOTOMY.
>>>>>>>>>
>>>>>>>>> All the ones that fail to abort
>>>>>>>>
>>>>>>>> Are in the set that fail to abort, [set(a)]
>>>>>>>> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>>>>>>>>
>>>>>>>> Instead of the deceptive names of the individual members we can
>>>>>>>> call them set (a) and set (b).
>>>>>>>
>>>>>>> Fine, and you have shown that we needed to abort all of the
>>>>>>> simulations of D built on an H in set (a).
>>>>>>>
>>>>>>> That DOESN'T meen that it was correct to abort the simulation of
>>>>>>> any of the Ds built from an H from set (b).
>>>>>>>
>>>>>>
>>>>>> By definition every (a) is wrong and every (b) is correct.
>>>>>
>>>>> Then you need tp be "Stipulating" sucn a definition of "Correct" to
>>>>> include proven INCORRECT answwers and admit that you logic is based
>>>>> on lying.
>>>>>
>>>>
>>>> Try and clearly show how any element of (b) is incorrect
>>>> using set theory.
>>>
>>> Set theory doesn't have the tools to do it.
>>>
>>> You are just proving your stupidity.
>>>
>>>>
>>>>>
>>>>>>
>>>>>>>>
>>>>>>>> It is like you are trying to get away with claiming that
>>>>>>>> some of the living things THAT ARE ANIMALS ARE NOT ANIMALS
>>>>>>>> by referring to the subset of cats.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, YOU are the one make claims about things that you can't
>>>>>>> actually show.
>>>>>>>
>>>>>>
>>>>>> *Let's try and formalize this more precisely with set theory*
>>>>>>
>>>>>> X are H/D pairs where H simulates D.
>>>>>> Y are the subset of X where H does not abort its simulation.
>>>>>> Z are the subset of X where H aborts its simulation.
>>>>>>
>>>>>> All X are Y xor Z
>>>>>> All Y are incorrect
>>>>>> All Z are correct
>>>>>>
>>>>>
>>>>>
>>>>> Why are all Z correct?
>>>>>
>>>>> Remember, D's behavior changes based on what H it is paired with.
>>>>>
>>>> It does not change in any relevant way.
>>>
>>> Of course it does.
>>>
>>> DO you considdr being Non-Halting vs Halting not a "relevent" fact?
>>>
>>> I guess you REALLY think cats can be 10 story office buildings.
>>>
>>>> Try and show how it changes in a relevant way.
>>>
>>> D(D) based on an H that never aborts its simulation of this input
>>> will be non-halting.
>>>
>>> D(D) based on an H that DOES abort its simulation simulation of this
>>> input, and returns non-halting will be halting.
>>>
>>
>> I am saying that H/D pairs where H simulates D that this D right here
>> not some other D somewhere else never reaches its own line 06.
>
> Right. But that doesn't prove that the D is non-halting of H gives up on
> its simulation.
>

Op 26.mrt.2024 om 01:44 schreef olcott:
> On 3/25/2024 7:31 PM, Richard Damon wrote:
>> On 3/25/24 8:22 PM, olcott wrote:
>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>>>>>>
>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>
>>>>>>>>>>>> As can be seen above, if H returns false in line 03, then D
>>>>>>>>>>>> will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>
>>>>>>>>>> Even a beginner in C will see that if the simulated D, using
>>>>>>>>>> the H that is programmed to abort and return false, will
>>>>>>>>>> continue with line 04 then line 06 and halt (unless aborted).
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 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 }
>>>>>>>>>
>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>>> its own line 06 and halt.
>>>>>>>>
>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>>> possibly
>>>>>>>>>>> return to its caller. The relationship between the simulated
>>>>>>>>>>> D(D)
>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>> isomorphic
>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>
>>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>>> which makes that also the simulated H is programmed to abort
>>>>>>>>>> and return false.
>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>> instance
>>>>>>>>>>> that does not have this same pathological relationship is summed
>>>>>>>>>>> up in your own reply.
>>>>>>>>>>
>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>
>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>
>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>> programming skill.
>>>>>>>>>
>>>>>>>>>> It seems too difficult for olcott to see, what even a beginner
>>>>>>>>>> sees, that H, programmed to return false, also returns false
>>>>>>>>>> when simulated (unless aborted).
>>>>>>>>>
>>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>>> programs that they reviewed and they reviewed all of the programs.
>>>>>>>>
>>>>>>>> If true, I am very sorry for olcott, that he is no longer able
>>>>>>>> to see, what even a beginner sees, that H, programmed to return
>>>>>>>> false, also returns false when simulated (unless aborted).
>>>>>>>
>>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>>> verified fact:
>>>>>>>
>>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>>> state*
>>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>>> Some of these people might lie about it.
>>>>>>>
>>>>>>
>>>>>> Everyone with sufficient programming skill can see that H is not
>>>>>> defined as part of program D, and if you define H inside program
>>>>>> D, then it might be possible to tell whether it reaches line 06 or
>>>>>> not.
>>>>>
>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>>>>> Every other detail about H is unspecified because it is irrelevant.
>>>>
>>>>
>>>> Then your stipulation is just ILLOGICAL, as a given H can only do
>>>> one thing.
>>>
>>> None-the-less they all share the common property that they either
>>> run forever or abort the simulation of their input. All of the other
>>> differences don't make and damn difference at all.
>>>
>>
>> But that isn't a simple property, so you are creating a FALSE DICHOTOMY.
>>
>> All the ones that fail to abort
>
> Are in the set that fail to abort, [set(a)]
> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>
> Instead of the deceptive names of the individual members we can
> call them set (a) and set (b).

Op 26.mrt.2024 om 01:44 schreef olcott:
> On 3/25/2024 7:31 PM, Richard Damon wrote:
>> On 3/25/24 8:22 PM, olcott wrote:
>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>>>>>>
>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>
>>>>>>>>>>>> As can be seen above, if H returns false in line 03, then D
>>>>>>>>>>>> will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>
>>>>>>>>>> Even a beginner in C will see that if the simulated D, using
>>>>>>>>>> the H that is programmed to abort and return false, will
>>>>>>>>>> continue with line 04 then line 06 and halt (unless aborted).
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 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 }
>>>>>>>>>
>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>>> its own line 06 and halt.
>>>>>>>>
>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>>> possibly
>>>>>>>>>>> return to its caller. The relationship between the simulated
>>>>>>>>>>> D(D)
>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>> isomorphic
>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>
>>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>>> which makes that also the simulated H is programmed to abort
>>>>>>>>>> and return false.
>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>> instance
>>>>>>>>>>> that does not have this same pathological relationship is summed
>>>>>>>>>>> up in your own reply.
>>>>>>>>>>
>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>
>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>
>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>> programming skill.
>>>>>>>>>
>>>>>>>>>> It seems too difficult for olcott to see, what even a beginner
>>>>>>>>>> sees, that H, programmed to return false, also returns false
>>>>>>>>>> when simulated (unless aborted).
>>>>>>>>>
>>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>>> programs that they reviewed and they reviewed all of the programs.
>>>>>>>>
>>>>>>>> If true, I am very sorry for olcott, that he is no longer able
>>>>>>>> to see, what even a beginner sees, that H, programmed to return
>>>>>>>> false, also returns false when simulated (unless aborted).
>>>>>>>
>>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>>> verified fact:
>>>>>>>
>>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>>> state*
>>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>>> Some of these people might lie about it.
>>>>>>>
>>>>>>
>>>>>> Everyone with sufficient programming skill can see that H is not
>>>>>> defined as part of program D, and if you define H inside program
>>>>>> D, then it might be possible to tell whether it reaches line 06 or
>>>>>> not.
>>>>>
>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>>>>> Every other detail about H is unspecified because it is irrelevant.
>>>>
>>>>
>>>> Then your stipulation is just ILLOGICAL, as a given H can only do
>>>> one thing.
>>>
>>> None-the-less they all share the common property that they either
>>> run forever or abort the simulation of their input. All of the other
>>> differences don't make and damn difference at all.
>>>
>>
>> But that isn't a simple property, so you are creating a FALSE DICHOTOMY.
>>
>> All the ones that fail to abort
>
> Are in the set that fail to abort, [set(a)]
> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]

On 3/25/24 11:34 PM, olcott wrote:
> On 3/25/2024 10:06 PM, Richard Damon wrote:
>> On 3/25/24 10:57 PM, olcott wrote:
>>> On 3/25/2024 9:44 PM, Richard Damon wrote:
>>>> On 3/25/24 10:19 PM, olcott wrote:
>>>>> On 3/25/2024 9:04 PM, Richard Damon wrote:
>>>>>> On 3/25/24 9:28 PM, olcott wrote:
>>>>>>> On 3/25/2024 7:55 PM, Richard Damon wrote:
>>>>>>>> On 3/25/24 8:44 PM, olcott wrote:
>>>>>>>>> On 3/25/2024 7:31 PM, Richard Damon wrote:
>>>>>>>>>> On 3/25/24 8:22 PM, olcott wrote:
>>>>>>>>>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>>>>>>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>>>>>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>>>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is self-evident that when H is programmed to
>>>>>>>>>>>>>>>>>>>>>> abort and return false, then [the simulated] D will
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> immediately stop running never having reached its
>>>>>>>>>>>>>>>>>>>>> last instruction to halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> As can be seen above, if H returns false in line 03,
>>>>>>>>>>>>>>>>>>>> then D will go to line 04 and line 06 and halt
>>>>>>>>>>>>>>>>>>>> (unless aborted).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You still do not understand that functions called in
>>>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>>>> recursion never return to their caller, thus must
>>>>>>>>>>>>>>>>>>> have grossly
>>>>>>>>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Even a beginner in C will see that if the simulated D,
>>>>>>>>>>>>>>>>>> using the H that is programmed to abort and return
>>>>>>>>>>>>>>>>>> false, will continue with line 04 then line 06 and
>>>>>>>>>>>>>>>>>> halt (unless aborted).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is the strawman deception we are only talking
>>>>>>>>>>>>>>>>> about the
>>>>>>>>>>>>>>>>> fact that the D correctly simulated by H cannot
>>>>>>>>>>>>>>>>> possibly reach
>>>>>>>>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When the simulated D calls its simulator this call
>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>> return to its caller. The relationship between the
>>>>>>>>>>>>>>>>>>> simulated D(D)
>>>>>>>>>>>>>>>>>>> and its simulator makes a call D(D) to its own
>>>>>>>>>>>>>>>>>>> simulator isomorphic
>>>>>>>>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is exactly the relation with the simulator that
>>>>>>>>>>>>>>>>>> aborts, which makes that also the simulated H is
>>>>>>>>>>>>>>>>>> programmed to abort and return false.
>>>>>>>>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That the directly executed D(D) is an entirely
>>>>>>>>>>>>>>>>>>> different instance
>>>>>>>>>>>>>>>>>>> that does not have this same pathological
>>>>>>>>>>>>>>>>>>> relationship is summed
>>>>>>>>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>>>>> I am not talking about a directly executed D, but a
>>>>>>>>>>>>>>>>>> simulated D!
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly reach its
>>>>>>>>>>>>>>>>> own line
>>>>>>>>>>>>>>>>> 06 and halt. That you say otherwise proves your
>>>>>>>>>>>>>>>>> insufficient
>>>>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>>>>>>>>> beginner sees, that H, programmed to return false,
>>>>>>>>>>>>>>>>>> also returns false when simulated (unless aborted).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When I worked at the US Army Corps of engineers an
>>>>>>>>>>>>>>>>> independent
>>>>>>>>>>>>>>>>> contractor rated my programs as the best quality of all
>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>> programs that they reviewed and they reviewed all of
>>>>>>>>>>>>>>>>> the programs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If true, I am very sorry for olcott, that he is no
>>>>>>>>>>>>>>>> longer able to see, what even a beginner sees, that H,
>>>>>>>>>>>>>>>> programmed to return false, also returns false when
>>>>>>>>>>>>>>>> simulated (unless aborted).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Everyone with sufficient programming skill can see that
>>>>>>>>>>>>>>> this is a
>>>>>>>>>>>>>>> verified fact:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>>>>>> final state*
>>>>>>>>>>>>>>> *at line 06 in an infinite number of steps of correct
>>>>>>>>>>>>>>> simulation*
>>>>>>>>>>>>>>> Some of these people might lie about it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Everyone with sufficient programming skill can see that H
>>>>>>>>>>>>>> is not defined as part of program D, and if you define H
>>>>>>>>>>>>>> inside program D, then it might be possible to tell
>>>>>>>>>>>>>> whether it reaches line 06 or not.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *It is stipulated that H must correctly simulate 1 to ∞
>>>>>>>>>>>>> steps of D*
>>>>>>>>>>>>> Every other detail about H is unspecified because it is
>>>>>>>>>>>>> irrelevant.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then your stipulation is just ILLOGICAL, as a given H can
>>>>>>>>>>>> only do one thing.
>>>>>>>>>>>
>>>>>>>>>>> None-the-less they all share the common property that they
>>>>>>>>>>> either
>>>>>>>>>>> run forever or abort the simulation of their input. All of
>>>>>>>>>>> the other
>>>>>>>>>>> differences don't make and damn difference at all.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But that isn't a simple property, so you are creating a FALSE
>>>>>>>>>> DICHOTOMY.
>>>>>>>>>>
>>>>>>>>>> All the ones that fail to abort
>>>>>>>>>
>>>>>>>>> Are in the set that fail to abort, [set(a)]
>>>>>>>>> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>>>>>>>>>
>>>>>>>>> Instead of the deceptive names of the individual members we can
>>>>>>>>> call them set (a) and set (b).
>>>>>>>>
>>>>>>>> Fine, and you have shown that we needed to abort all of the
>>>>>>>> simulations of D built on an H in set (a).
>>>>>>>>
>>>>>>>> That DOESN'T meen that it was correct to abort the simulation of
>>>>>>>> any of the Ds built from an H from set (b).
>>>>>>>>
>>>>>>>
>>>>>>> By definition every (a) is wrong and every (b) is correct.
>>>>>>
>>>>>> Then you need tp be "Stipulating" sucn a definition of "Correct"
>>>>>> to include proven INCORRECT answwers and admit that you logic is
>>>>>> based on lying.
>>>>>>
>>>>>
>>>>> Try and clearly show how any element of (b) is incorrect
>>>>> using set theory.
>>>>
>>>> Set theory doesn't have the tools to do it.
>>>>
>>>> You are just proving your stupidity.
>>>>
>>>>>
>>>>>>
>>>>>>>
>>>>>>>>>
>>>>>>>>> It is like you are trying to get away with claiming that
>>>>>>>>> some of the living things THAT ARE ANIMALS ARE NOT ANIMALS
>>>>>>>>> by referring to the subset of cats.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, YOU are the one make claims about things that you can't
>>>>>>>> actually show.
>>>>>>>>
>>>>>>>
>>>>>>> *Let's try and formalize this more precisely with set theory*
>>>>>>>
>>>>>>> X are H/D pairs where H simulates D.
>>>>>>> Y are the subset of X where H does not abort its simulation.
>>>>>>> Z are the subset of X where H aborts its simulation.
>>>>>>>
>>>>>>> All X are Y xor Z
>>>>>>> All Y are incorrect
>>>>>>> All Z are correct
>>>>>>>
>>>>>>
>>>>>>
>>>>>> Why are all Z correct?
>>>>>>
>>>>>> Remember, D's behavior changes based on what H it is paired with.
>>>>>>
>>>>> It does not change in any relevant way.
>>>>
>>>> Of course it does.
>>>>
>>>> DO you considdr being Non-Halting vs Halting not a "relevent" fact?
>>>>
>>>> I guess you REALLY think cats can be 10 story office buildings.
>>>>
>>>>> Try and show how it changes in a relevant way.
>>>>
>>>> D(D) based on an H that never aborts its simulation of this input
>>>> will be non-halting.
>>>>
>>>> D(D) based on an H that DOES abort its simulation simulation of this
>>>> input, and returns non-halting will be halting.
>>>>
>>>
>>> I am saying that H/D pairs where H simulates D that this D right here
>>> not some other D somewhere else never reaches its own line 06.
>>
>> Right. But that doesn't prove that the D is non-halting of H gives up
>> on its simulation.
>>
>
> You always use the strawman deception on this.
> WE ARE TALKING ABOUT ABORT DECIDERS
> WE ARE TALKING ABOUT ABORT DECIDERS
> WE ARE TALKING ABOUT ABORT DECIDERS
> WE ARE TALKING ABOUT ABORT DECIDERS
> WE ARE TALKING ABOUT ABORT DECIDERS

On 3/26/2024 6:39 AM, Richard Damon wrote:
> On 3/25/24 11:34 PM, olcott wrote:
>> On 3/25/2024 10:06 PM, Richard Damon wrote:
>>> On 3/25/24 10:57 PM, olcott wrote:

<snip>

>>>> I am saying that H/D pairs where H simulates D that this D right here
>>>> not some other D somewhere else never reaches its own line 06.
>>>
>>> Right. But that doesn't prove that the D is non-halting of H gives up
>>> on its simulation.
>>>
>>
>> You always use the strawman deception on this.
>> WE ARE TALKING ABOUT ABORT DECIDERS
>> WE ARE TALKING ABOUT ABORT DECIDERS
>> WE ARE TALKING ABOUT ABORT DECIDERS
>> WE ARE TALKING ABOUT ABORT DECIDERS
>> WE ARE TALKING ABOUT ABORT DECIDERS
>
> And you have agreed that an "Abort Deciders" will decide based on if
> THIS DECIDER needs to abort THIS 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 }

This decider must abort this input when-so-ever this H/D pair is in
the set of H/D pairs where H simulates its input and D is defined as
specified above.

> based on if an actual CORRECT
> SIMULATION of THIS INPUT will run forever or Halt.
>
> You are stuck with that definition if you want your "abort deciders" to
> be at all related to "Halt Deciders", which since you continue to refer
> to the Halting problem proofs, you do, you need to use THAT definition.
>
> Any definition based on looking at the behavior of some other machine
> and input, is just illogical, but then, you have shown that you thinking
> goes to illogical ideas.
>

By that same reasoning cats have no common attributes and some cats
might bark and some cats might fly because not all cats are exactly
the same.

>>
>>> If that was all that was needed, ALL inputs could be correctly
>>> decided as non-halting.
>>>
>>
>> WE ARE TALKING ABOUT ABORT DECIDERS
>> WE ARE TALKING ABOUT ABORT DECIDERS
>> WE ARE TALKING ABOUT ABORT DECIDERS
>> WE ARE TALKING ABOUT ABORT DECIDERS
>> WE ARE TALKING ABOUT ABORT DECIDERS
>
> Right, based on the actual NEED for THIS decider to abort for this exact
> input.
>

This decider must abort this input when-so-ever this H/D pair is in
the set of H/D pairs where H simulates its input and D is defined as
specified above.

> Since, for our H(D,D) that is programmed to abort and return 0, the D(D)

I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.
I never said that, about abort deciders I only said that H simulates D.

> built on it will halt, then this H(D,D) did not NEED to abort it, but did.
>
>
>>
>>>>
>>>>> Since H is supposed to be a "Halt Decider", the HALTING PROPERTY of
>>>>> the input is a very important and relevent fact.
>>>>>
>>>>> I guess you think TRUTH isn't relevent, only whether you can make a
>>>>> convincing lie.
>>>>>
>>>>>> Milk and Cheese and not the same yet both are dairy products.
>>>>>
>>>>> And Milk is a liquid and Cheese is a solid.
>>>>>
>>>>> Try to make a glass og "Chocolate Cheese"
>>>>>
>>>>> Or make a Pizza with "Milk" as a topping.
>>>>>
>>>>>>
>>>>>>> There is no reason to assume that ANY X are correct, that is your
>>>>>>> INCORRECT assumption,
>>>>>>>
>>>>>>
>>>>>> All H that never halt have incorrect halting behavior for a decider.
>>>>>> All H that halt have correct halting behavior for a decider.
>>>>>
>>>>> That may make them DECIDERS, but not a HALT DECIDER if they say
>>>>> non-halting for an input you have admitted is Halting.
>>>>>
>>>>> You are just PROVING that you are just a pathetic hypocritical
>>>>> ignorant pathological lying idiot.
>>>>>
>>>>
>>>> Are you willing to bet your soul on that?
>>>
>>> Sure, are YOU?
>>
>> I know that my soul is the one thing that I cannot afford
>> to lose, and what the Hell would I do with two souls when I win?
>> I would not bet my soul that 2 + 3 = 5.
>
> Seems you have already lost it.
>
> And you or I will not be the one to collect.
>
I don't believe that because a woman lied about her weight
by one pound one time that she will

*Revelation 21:8 NRSV*
....and all liars, their place will be in the lake that burns with
fire and sulphur, which is the second death.’

I also know that God <is> Love and God <has> Wrath is impossibly
true. It is the same as H2O <is> water and H2O <has> Carbon.
*I go by what makes the most sense*

What seems to make the most sense is that we concatenate
"with as much empathy as possible" to the commandment to
"love one another" and abolish the distraction of all of the
other commandments so that we can unite in a single-minded
focus on loving others.

*Galatians 5:14 NRSV*
For the whole law is summed up in a single commandment,
‘You shall love your neighbour as yourself.’

The reason that I persist in my proofs is that righteousness
must be anchored in truth and humans have totally screwed up
the notion of truth with incompleteness and undecidability.

Half the population believes that the 2020 presidential
election was stolen because liars told them so.

--
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/26/2024 4:16 AM, Fred. Zwarts wrote:
> Op 26.mrt.2024 om 01:44 schreef olcott:
>> On 3/25/2024 7:31 PM, Richard Damon wrote:
>>> On 3/25/24 8:22 PM, olcott wrote:
>>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> As can be seen above, if H returns false in line 03, then D
>>>>>>>>>>>>> will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>
>>>>>>>>>>> Even a beginner in C will see that if the simulated D, using
>>>>>>>>>>> the H that is programmed to abort and return false, will
>>>>>>>>>>> continue with line 04 then line 06 and halt (unless aborted).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>
>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>>>> possibly
>>>>>>>>>>>> return to its caller. The relationship between the simulated
>>>>>>>>>>>> D(D)
>>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>>> isomorphic
>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>
>>>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>>>> which makes that also the simulated H is programmed to abort
>>>>>>>>>>> and return false.
>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>>> instance
>>>>>>>>>>>> that does not have this same pathological relationship is
>>>>>>>>>>>> summed
>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>
>>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>>
>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>
>>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>>> programming skill.
>>>>>>>>>>
>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>> beginner sees, that H, programmed to return false, also
>>>>>>>>>>> returns false when simulated (unless aborted).
>>>>>>>>>>
>>>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>>>> programs that they reviewed and they reviewed all of the
>>>>>>>>>> programs.
>>>>>>>>>
>>>>>>>>> If true, I am very sorry for olcott, that he is no longer able
>>>>>>>>> to see, what even a beginner sees, that H, programmed to return
>>>>>>>>> false, also returns false when simulated (unless aborted).
>>>>>>>>
>>>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>>>> verified fact:
>>>>>>>>
>>>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>>>> state*
>>>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>>>> Some of these people might lie about it.
>>>>>>>>
>>>>>>>
>>>>>>> Everyone with sufficient programming skill can see that H is not
>>>>>>> defined as part of program D, and if you define H inside program
>>>>>>> D, then it might be possible to tell whether it reaches line 06
>>>>>>> or not.
>>>>>>
>>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>>>>>> Every other detail about H is unspecified because it is irrelevant.
>>>>>
>>>>>
>>>>> Then your stipulation is just ILLOGICAL, as a given H can only do
>>>>> one thing.
>>>>
>>>> None-the-less they all share the common property that they either
>>>> run forever or abort the simulation of their input. All of the other
>>>> differences don't make and damn difference at all.
>>>>
>>>
>>> But that isn't a simple property, so you are creating a FALSE DICHOTOMY.
>>>
>>> All the ones that fail to abort
>>
>> Are in the set that fail to abort, [set(a)]
>> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>>
>> Instead of the deceptive names of the individual members we can
>> call them set (a) and set (b).
>
> Did olcott really make a step forward? He really starts to use different
> names for different things. Unbelievable!
> Lets call the H in set a Ha and the H in set b Hb. Further note that D
> is unspecified as long as H is not defined.

On 3/26/2024 6:23 AM, Fred. Zwarts wrote:
> Op 26.mrt.2024 om 01:44 schreef olcott:
>> On 3/25/2024 7:31 PM, Richard Damon wrote:
>>> On 3/25/24 8:22 PM, olcott wrote:
>>>> On 3/25/2024 6:44 PM, Richard Damon wrote:
>>>>> On 3/25/24 2:07 PM, olcott wrote:
>>>>>> On 3/23/2024 5:19 PM, immibis wrote:
>>>>>>> On 23/03/24 20:26, olcott wrote:
>>>>>>>> On 3/23/2024 1:57 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 23.mrt.2024 om 17:53 schreef olcott:
>>>>>>>>>> On 3/23/2024 11:31 AM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 23.mrt.2024 om 17:08 schreef olcott:
>>>>>>>>>>>> On 3/23/2024 9:43 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 23.mrt.2024 om 14:58 schreef olcott:
>>>>>>>>>>>>>> On 3/23/2024 4:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 22.mrt.2024 om 19:41 schreef olcott:
>>>>>>>>>>>>>>>> 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 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H is a simulating abort decider that supposed to
>>>>>>>>>>>>>>>> correctly determine whether or not it needs to abort
>>>>>>>>>>>>>>>> the simulation of any pathological inputs that are
>>>>>>>>>>>>>>>> attempting to thwart this abort decision.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H must abort every simulated input that would not
>>>>>>>>>>>>>>>> otherwise halt to prevent its own non-termination.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is a self-evident verified fact that every H(D,D)
>>>>>>>>>>>>>>>> that decides to abort its simulated D(D) is correct
>>>>>>>>>>>>>>>> in doing so because this does prevent its own
>>>>>>>>>>>>>>>> non-termination.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is self-evident that when H is programmed to abort and
>>>>>>>>>>>>>>> return false, then [the simulated] D will
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> immediately stop running never having reached its last
>>>>>>>>>>>>>> instruction to halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> As can be seen above, if H returns false in line 03, then D
>>>>>>>>>>>>> will go to line 04 and line 06 and halt (unless aborted).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You still do not understand that functions called in infinite
>>>>>>>>>>>> recursion never return to their caller, thus must have grossly
>>>>>>>>>>>> exaggerated your programming skill.
>>>>>>>>>>>
>>>>>>>>>>> Even a beginner in C will see that if the simulated D, using
>>>>>>>>>>> the H that is programmed to abort and return false, will
>>>>>>>>>>> continue with line 04 then line 06 and halt (unless aborted).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>> That is the strawman deception we are only talking about the
>>>>>>>>>> fact that the D correctly simulated by H cannot possibly reach
>>>>>>>>>> its own line 06 and halt.
>>>>>>>>>
>>>>>>>>> Denying a verified fact is not a strong rebuttal.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>> When the simulated D calls its simulator this call cannot
>>>>>>>>>>>> possibly
>>>>>>>>>>>> return to its caller. The relationship between the simulated
>>>>>>>>>>>> D(D)
>>>>>>>>>>>> and its simulator makes a call D(D) to its own simulator
>>>>>>>>>>>> isomorphic
>>>>>>>>>>>> to infinite recursion.
>>>>>>>>>>>
>>>>>>>>>>> It is exactly the relation with the simulator that aborts,
>>>>>>>>>>> which makes that also the simulated H is programmed to abort
>>>>>>>>>>> and return false.
>>>>>>>>>>> Olcott is again contradicting himself.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That the directly executed D(D) is an entirely different
>>>>>>>>>>>> instance
>>>>>>>>>>>> that does not have this same pathological relationship is
>>>>>>>>>>>> summed
>>>>>>>>>>>> up in your own reply.
>>>>>>>>>>>
>>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>> I am not talking about a directly executed D, but a simulated D!
>>>>>>>>>>>
>>>>>>>>>>> This simulated D halts (unless aborted)!
>>>>>>>>>>
>>>>>>>>>> D correctly simulated by H cannot possibly reach its own line
>>>>>>>>>> 06 and halt. That you say otherwise proves your insufficient
>>>>>>>>>> programming skill.
>>>>>>>>>>
>>>>>>>>>>> It seems too difficult for olcott to see, what even a
>>>>>>>>>>> beginner sees, that H, programmed to return false, also
>>>>>>>>>>> returns false when simulated (unless aborted).
>>>>>>>>>>
>>>>>>>>>> When I worked at the US Army Corps of engineers an independent
>>>>>>>>>> contractor rated my programs as the best quality of all of the
>>>>>>>>>> programs that they reviewed and they reviewed all of the
>>>>>>>>>> programs.
>>>>>>>>>
>>>>>>>>> If true, I am very sorry for olcott, that he is no longer able
>>>>>>>>> to see, what even a beginner sees, that H, programmed to return
>>>>>>>>> false, also returns false when simulated (unless aborted).
>>>>>>>>
>>>>>>>> Everyone with sufficient programming skill can see that this is a
>>>>>>>> verified fact:
>>>>>>>>
>>>>>>>> *D correctly simulated by H cannot possibly reach its own final
>>>>>>>> state*
>>>>>>>> *at line 06 in an infinite number of steps of correct simulation*
>>>>>>>> Some of these people might lie about it.
>>>>>>>>
>>>>>>>
>>>>>>> Everyone with sufficient programming skill can see that H is not
>>>>>>> defined as part of program D, and if you define H inside program
>>>>>>> D, then it might be possible to tell whether it reaches line 06
>>>>>>> or not.
>>>>>>
>>>>>> *It is stipulated that H must correctly simulate 1 to ∞ steps of D*
>>>>>> Every other detail about H is unspecified because it is irrelevant.
>>>>>
>>>>>
>>>>> Then your stipulation is just ILLOGICAL, as a given H can only do
>>>>> one thing.
>>>>
>>>> None-the-less they all share the common property that they either
>>>> run forever or abort the simulation of their input. All of the other
>>>> differences don't make and damn difference at all.
>>>>
>>>
>>> But that isn't a simple property, so you are creating a FALSE DICHOTOMY.
>>>
>>> All the ones that fail to abort
>>
>> Are in the set that fail to abort, [set(a)]
>> LEAVING ALL OF THE OTHER ONES IN THE SET THAT ABORTS [set(b)]
>
> Maybe there is some progress, now that even olcott uses names.
> According olcott the whole set of H can be split in set(a) and set(b).
> All H in set(a) are wrong, therefore all H is set(b) must be correct.
Yes.

On 3/26/24 11:13 AM, olcott wrote:
> On 3/26/2024 6:39 AM, Richard Damon wrote:
>> On 3/25/24 11:34 PM, olcott wrote:
>>> On 3/25/2024 10:06 PM, Richard Damon wrote:
>>>> On 3/25/24 10:57 PM, olcott wrote:
>
> <snip>
>
>>>>> I am saying that H/D pairs where H simulates D that this D right here
>>>>> not some other D somewhere else never reaches its own line 06.
>>>>
>>>> Right. But that doesn't prove that the D is non-halting of H gives
>>>> up on its simulation.
>>>>
>>>
>>> You always use the strawman deception on this.
>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>
>> And you have agreed that an "Abort Deciders" will decide based on if
>> THIS DECIDER needs to abort THIS 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 }
>
> This decider must abort this input when-so-ever this H/D pair is in
> the set of H/D pairs where H simulates its input and D is defined as
> specified above.

H must do what H does.

First note, you have strayed from the actual definiton of the problem,
(andthus are LYING about following it) because the specific D was
DEFINED to use a specific COPY of the one decider it was designed to refute.

Your D ends up failing to even be a Computation, (when you limit the
desciption of D to NOT include H) because its behavior is NOT fully defined.

Yes, any H that doesn't happen to abort its simulation is not a correct
decider because it will fail to decide.

That DOESN'T mean that an H that does abort is correct, as every
different H that is called by D creates a different behavior for D, and
in effect, creates a "new" D, even though its description (by your
stipulation) is the same, but that is because you have created a
non-computation input, and for those, to determine there behavior, we
need to include the appropriate extra "hidden" information, which in
this case is the code of H.

Now, if H does abort and return 0, then it is clear that that makes a
D(D) that will halt, as can be proved by having main call UTM(D,D) with
that D still refering to that original H (which you keep on trying to
lie about not being able to do).

Sincd that simulation will reach an end, then it is shown that these Hs
don't actually NEED to abort, even though (or because of the fact) they do.

You can claim this make this an invalid question, and I would agree,
because your D was built wrong. Build D the RIGHT way, with its own copy
of H (that is fixed to be the H you finally decide on, and doesn't
change during your argument) then the question is valid, and the H that
D was built on is clearly wrong, and any other decider could have its
own "pathelogical" input defined that makes IT wrong.

>
>>  based on if an actual CORRECT SIMULATION of THIS INPUT will run
>> forever or Halt.
>>
>> You are stuck with that definition if you want your "abort deciders"
>> to be at all related to "Halt Deciders", which since you continue to
>> refer to the Halting problem proofs, you do, you need to use THAT
>> definition.
>>
>> Any definition based on looking at the behavior of some other machine
>> and input, is just illogical, but then, you have shown that you
>> thinking goes to illogical ideas.
>>
>
> By that same reasoning cats have no common attributes and some cats
> might bark and some cats might fly because not all cats are exactly
> the same.

Not *NO* common attributes, but have some differences, so if you thing
being looked at varies, then not all cat are the same.

For instance, not all cats are black.

You just don't seem to understand the nature of "Categories"

>
>>>
>>>> If that was all that was needed, ALL inputs could be correctly
>>>> decided as non-halting.
>>>>
>>>
>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>
>> Right, based on the actual NEED for THIS decider to abort for this
>> exact input.
>>
>
> This decider must abort this input when-so-ever this H/D pair is in
> the set of H/D pairs where H simulates its input and D is defined as
> specified above.

It must abort to be a decider.

Thst doesn't mean that if it does abort, it knows the right answer to
the question about the input halting (or needing to be aborted).

They are NOT the same criteria,

>
>> Since, for our H(D,D) that is programmed to abort and return 0, the D(D)
>
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.
> I never said that, about abort deciders I only said that H simulates D.

So, are you talking about the ones that do abort, or the ones that don't.

You DO understand that these are DIFFERENT programs, and each must be
looked at individually.

The question is NOT about "classes of Deciders" pair with a "Class of
Inputs".

The quesiton is about ONE SPECIFIC INPUT, and the answer that ONE
SPECIFIC decider gives.

You are just proving you just don't know what you are talking about.

>
>> built on it will halt, then this H(D,D) did not NEED to abort it, but
>> did.
>>
>>
>>>
>>>>>
>>>>>> Since H is supposed to be a "Halt Decider", the HALTING PROPERTY
>>>>>> of the input is a very important and relevent fact.
>>>>>>
>>>>>> I guess you think TRUTH isn't relevent, only whether you can make
>>>>>> a convincing lie.
>>>>>>
>>>>>>> Milk and Cheese and not the same yet both are dairy products.
>>>>>>
>>>>>> And Milk is a liquid and Cheese is a solid.
>>>>>>
>>>>>> Try to make a glass og "Chocolate Cheese"
>>>>>>
>>>>>> Or make a Pizza with "Milk" as a topping.
>>>>>>
>>>>>>>
>>>>>>>> There is no reason to assume that ANY X are correct, that is
>>>>>>>> your INCORRECT assumption,
>>>>>>>>
>>>>>>>
>>>>>>> All H that never halt have incorrect halting behavior for a decider.
>>>>>>> All H that halt have correct halting behavior for a decider.
>>>>>>
>>>>>> That may make them DECIDERS, but not a HALT DECIDER if they say
>>>>>> non-halting for an input you have admitted is Halting.
>>>>>>
>>>>>> You are just PROVING that you are just a pathetic hypocritical
>>>>>> ignorant pathological lying idiot.
>>>>>>
>>>>>
>>>>> Are you willing to bet your soul on that?
>>>>
>>>> Sure, are YOU?
>>>
>>> I know that my soul is the one thing that I cannot afford
>>> to lose, and what the Hell would I do with two souls when I win?
>>> I would not bet my soul that 2 + 3 = 5.
>>
>> Seems you have already lost it.
>>
>> And you or I will not be the one to collect.
>>
> I don't believe that because a woman lied about her weight
> by one pound one time that she will

On 3/26/2024 9:18 PM, Richard Damon wrote:
> On 3/26/24 11:13 AM, olcott wrote:
>> On 3/26/2024 6:39 AM, Richard Damon wrote:
>>> On 3/25/24 11:34 PM, olcott wrote:
>>>> On 3/25/2024 10:06 PM, Richard Damon wrote:
>>>>> On 3/25/24 10:57 PM, olcott wrote:
>>
>> <snip>
>>
>>>>>> I am saying that H/D pairs where H simulates D that this D right here
>>>>>> not some other D somewhere else never reaches its own line 06.
>>>>>
>>>>> Right. But that doesn't prove that the D is non-halting of H gives
>>>>> up on its simulation.
>>>>>
>>>>
>>>> You always use the strawman deception on this.
>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>
>>> And you have agreed that an "Abort Deciders" will decide based on if
>>> THIS DECIDER needs to abort THIS 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 }
>>
>> This decider must abort this input when-so-ever this H/D pair is in
>> the set of H/D pairs where H simulates its input and D is defined as
>> specified above.
>
> H must do what H does.
>
> First note, you have strayed from the actual definiton of the problem,
> (andthus are LYING about following it) because the specific D was
> DEFINED to use a specific COPY of the one decider it was designed to
> refute.
>
> Your D ends up failing to even be a Computation, (when you limit the
> desciption of D to NOT include H) because its behavior is NOT fully
> defined.
>
> Yes, any H that doesn't happen to abort its simulation is not a correct
> decider because it will fail to decide.
>
> That DOESN'T mean that an H that does abort is correct, as every
> different H that is called by D creates a different behavior for D, and
> in effect, creates a "new" D, even though its description (by your
> stipulation) is the same, but that is because you have created a
> non-computation input, and for those, to determine there behavior, we
> need to include the appropriate extra "hidden" information, which in
> this case is the code of H.
>
> Now, if H does abort and return 0, then it is clear that that makes a
> D(D) that will halt, as can be proved by having main call UTM(D,D) with
> that D still refering to that original H (which you keep on trying to
> lie about not being able to do).
>
> Sincd that simulation will reach an end, then it is shown that these Hs
> don't actually NEED to abort, even though (or because of the fact) they do.
>
> You can claim this make this an invalid question, and I would agree,
> because your D was built wrong. Build D the RIGHT way, with its own copy
> of H (that is fixed to be the H you finally decide on, and doesn't
> change during your argument) then the question is valid, and the H that
> D was built on is clearly wrong, and any other decider could have its
> own "pathelogical" input defined that makes IT wrong.
>
>>
>>>  based on if an actual CORRECT SIMULATION of THIS INPUT will run
>>> forever or Halt.
>>>
>>> You are stuck with that definition if you want your "abort deciders"
>>> to be at all related to "Halt Deciders", which since you continue to
>>> refer to the Halting problem proofs, you do, you need to use THAT
>>> definition.
>>>
>>> Any definition based on looking at the behavior of some other machine
>>> and input, is just illogical, but then, you have shown that you
>>> thinking goes to illogical ideas.
>>>
>>
>> By that same reasoning cats have no common attributes and some cats
>> might bark and some cats might fly because not all cats are exactly
>> the same.
>
> Not *NO* common attributes, but have some differences, so if you thing
> being looked at varies, then not all cat are the same.
>
> For instance, not all cats are black.
>
> You just don't seem to understand the nature of "Categories"
>
>>
>>>>
>>>>> If that was all that was needed, ALL inputs could be correctly
>>>>> decided as non-halting.
>>>>>
>>>>
>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>
>>> Right, based on the actual NEED for THIS decider to abort for this
>>> exact input.
>>>
>>
>> This decider must abort this input when-so-ever this H/D pair is in
>> the set of H/D pairs where H simulates its input and D is defined as
>> specified above.
>
> It must abort to be a decider.
>
> Thst doesn't mean that if it does abort, it knows the right answer to
> the question about the input halting (or needing to be aborted).
>
> They are NOT the same criteria,
>
>>
>>> Since, for our H(D,D) that is programmed to abort and return 0, the D(D)
>>
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>> I never said that, about abort deciders I only said that H simulates D.
>
> So, are you talking about the ones that do abort, or the ones that don't.
>
> You DO understand that these are DIFFERENT programs, and each must be
> looked at individually.
>
> The question is NOT about "classes of Deciders" pair with a "Class of
> Inputs".
>
> The quesiton is about ONE SPECIFIC INPUT, and the answer that ONE
> SPECIFIC decider gives.
>
> You are just proving you just don't know what you are talking about.
>
>>
>>> built on it will halt, then this H(D,D) did not NEED to abort it, but
>>> did.
>>>
>>>
>>>>
>>>>>>
>>>>>>> Since H is supposed to be a "Halt Decider", the HALTING PROPERTY
>>>>>>> of the input is a very important and relevent fact.
>>>>>>>
>>>>>>> I guess you think TRUTH isn't relevent, only whether you can make
>>>>>>> a convincing lie.
>>>>>>>
>>>>>>>> Milk and Cheese and not the same yet both are dairy products.
>>>>>>>
>>>>>>> And Milk is a liquid and Cheese is a solid.
>>>>>>>
>>>>>>> Try to make a glass og "Chocolate Cheese"
>>>>>>>
>>>>>>> Or make a Pizza with "Milk" as a topping.
>>>>>>>
>>>>>>>>
>>>>>>>>> There is no reason to assume that ANY X are correct, that is
>>>>>>>>> your INCORRECT assumption,
>>>>>>>>>
>>>>>>>>
>>>>>>>> All H that never halt have incorrect halting behavior for a
>>>>>>>> decider.
>>>>>>>> All H that halt have correct halting behavior for a decider.
>>>>>>>
>>>>>>> That may make them DECIDERS, but not a HALT DECIDER if they say
>>>>>>> non-halting for an input you have admitted is Halting.
>>>>>>>
>>>>>>> You are just PROVING that you are just a pathetic hypocritical
>>>>>>> ignorant pathological lying idiot.
>>>>>>>
>>>>>>
>>>>>> Are you willing to bet your soul on that?
>>>>>
>>>>> Sure, are YOU?
>>>>
>>>> I know that my soul is the one thing that I cannot afford
>>>> to lose, and what the Hell would I do with two souls when I win?
>>>> I would not bet my soul that 2 + 3 = 5.
>>>
>>> Seems you have already lost it.
>>>
>>> And you or I will not be the one to collect.
>>>
>> I don't believe that because a woman lied about her weight
>> by one pound one time that she will
>
> No, and that isn't what a "Liar" is, the word means someone whose life
> is characterized by falsehoods. (like yours)
>
>>
>> *Revelation 21:8 NRSV*
>> ...and all liars, their place will be in the lake that burns with
>> fire and sulphur, which is the second death.’
>
> Right, but you need to look at the context, HIS PEOPLE are not in that
> group, and I know that my name is in the
>
>>
>> I also know that God <is> Love and God <has> Wrath is impossibly
>> true. It is the same as H2O <is> water and H2O <has> Carbon.
>> *I go by what makes the most sense*
>
> And that just shows that you do not know him.
>
> So, you WILL find that you will end in that lake of fire.
>
>>
>> What seems to make the most sense is that we concatenate
>> "with as much empathy as possible" to the commandment to
>> "love one another" and abolish the distraction of all of the
>> other commandments so that we can unite in a single-minded
>> focus on loving others.
>
> And all the other DERIVE from this, so they are not "abolished", but
> expalined.
>

On 3/27/2024 4:52 AM, Mikko wrote:
> On 2024-03-26 14:18:33 +0000, olcott said:
>
>> On 3/26/2024 4:55 AM, Mikko wrote:
>>> On 2024-03-22 18:41:35 +0000, olcott said:
>>>
>>>> 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 }
>>>>
>>>> H is a simulating abort decider that supposed to
>>>> correctly determine whether or not it needs to abort
>>>> the simulation of any pathological inputs that are
>>>> attempting to thwart this abort decision.
>>>
>>> You shouldn't use the name "H" for an abort decider.
>>> An abort decider should be called "A" like a halting
>>> decider is called "H": by the initial letter.
>>>
>>
>> H is going to become a halt decider as soon as it is understood to be
>> a correct abort decider that cannot be fooled.
>
> As long as it isn't it should be called A.
>

01 void B(ptr x) // ptr is pointer to void function
02 {
03 A(x, x);
04 return;
05 }
06
07 void main()
08 {
09 A(B,B);
10 }

*Execution Trace*
Line 09: main() invokes A(B,B);

*keeps repeating* (unless aborted)
Line 03: simulated B(B) invokes simulated A(B,B) that simulates B(B)

*Simulation invariant*
B correctly simulated by A cannot possibly reach past its own line 03.

The whole class of every A(B,B) that simulates its input
is divided into two sub-classes:
(a) A(B,B) that DOES NOT abort its simulation is incorrect
(ABOUT THIS ABORT DECISION)
because it would never halt and all deciders must always halt.

(b) A(B,N) that DOES abort its simulation is correct
(ABOUT THIS ABORT DECISION)
because it would halt and all deciders must always halt.

--
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/26/24 11:47 PM, olcott wrote:
> On 3/26/2024 9:18 PM, Richard Damon wrote:
>> On 3/26/24 11:13 AM, olcott wrote:
>>> On 3/26/2024 6:39 AM, Richard Damon wrote:
>>>> On 3/25/24 11:34 PM, olcott wrote:
>>>>> On 3/25/2024 10:06 PM, Richard Damon wrote:
>>>>>> On 3/25/24 10:57 PM, olcott wrote:
>>>
>>> <snip>
>>>
>>>>>>> I am saying that H/D pairs where H simulates D that this D right
>>>>>>> here
>>>>>>> not some other D somewhere else never reaches its own line 06.
>>>>>>
>>>>>> Right. But that doesn't prove that the D is non-halting of H gives
>>>>>> up on its simulation.
>>>>>>
>>>>>
>>>>> You always use the strawman deception on this.
>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>
>>>> And you have agreed that an "Abort Deciders" will decide based on if
>>>> THIS DECIDER needs to abort THIS 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 }
>>>
>>> This decider must abort this input when-so-ever this H/D pair is in
>>> the set of H/D pairs where H simulates its input and D is defined as
>>> specified above.
>>
>> H must do what H does.
>>
>> First note, you have strayed from the actual definiton of the problem,
>> (andthus are LYING about following it) because the specific D was
>> DEFINED to use a specific COPY of the one decider it was designed to
>> refute.
>>
>> Your D ends up failing to even be a Computation, (when you limit the
>> desciption of D to NOT include H) because its behavior is NOT fully
>> defined.
>>
>> Yes, any H that doesn't happen to abort its simulation is not a
>> correct decider because it will fail to decide.
>>
>> That DOESN'T mean that an H that does abort is correct, as every
>> different H that is called by D creates a different behavior for D,
>> and in effect, creates a "new" D, even though its description (by your
>> stipulation) is the same, but that is because you have created a
>> non-computation input, and for those, to determine there behavior, we
>> need to include the appropriate extra "hidden" information, which in
>> this case is the code of H.
>>
>> Now, if H does abort and return 0, then it is clear that that makes a
>> D(D) that will halt, as can be proved by having main call UTM(D,D)
>> with that D still refering to that original H (which you keep on
>> trying to lie about not being able to do).
>>
>> Sincd that simulation will reach an end, then it is shown that these
>> Hs don't actually NEED to abort, even though (or because of the fact)
>> they do.
>>
>> You can claim this make this an invalid question, and I would agree,
>> because your D was built wrong. Build D the RIGHT way, with its own
>> copy of H (that is fixed to be the H you finally decide on, and
>> doesn't change during your argument) then the question is valid, and
>> the H that D was built on is clearly wrong, and any other decider
>> could have its own "pathelogical" input defined that makes IT wrong.
>>
>>>
>>>>  based on if an actual CORRECT SIMULATION of THIS INPUT will run
>>>> forever or Halt.
>>>>
>>>> You are stuck with that definition if you want your "abort deciders"
>>>> to be at all related to "Halt Deciders", which since you continue to
>>>> refer to the Halting problem proofs, you do, you need to use THAT
>>>> definition.
>>>>
>>>> Any definition based on looking at the behavior of some other
>>>> machine and input, is just illogical, but then, you have shown that
>>>> you thinking goes to illogical ideas.
>>>>
>>>
>>> By that same reasoning cats have no common attributes and some cats
>>> might bark and some cats might fly because not all cats are exactly
>>> the same.
>>
>> Not *NO* common attributes, but have some differences, so if you thing
>> being looked at varies, then not all cat are the same.
>>
>> For instance, not all cats are black.
>>
>> You just don't seem to understand the nature of "Categories"
>>
>>>
>>>>>
>>>>>> If that was all that was needed, ALL inputs could be correctly
>>>>>> decided as non-halting.
>>>>>>
>>>>>
>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>
>>>> Right, based on the actual NEED for THIS decider to abort for this
>>>> exact input.
>>>>
>>>
>>> This decider must abort this input when-so-ever this H/D pair is in
>>> the set of H/D pairs where H simulates its input and D is defined as
>>> specified above.
>>
>> It must abort to be a decider.
>>
>> Thst doesn't mean that if it does abort, it knows the right answer to
>> the question about the input halting (or needing to be aborted).
>>
>> They are NOT the same criteria,
>>
>>>
>>>> Since, for our H(D,D) that is programmed to abort and return 0, the
>>>> D(D)
>>>
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>> I never said that, about abort deciders I only said that H simulates D.
>>
>> So, are you talking about the ones that do abort, or the ones that don't.
>>
>> You DO understand that these are DIFFERENT programs, and each must be
>> looked at individually.
>>
>> The question is NOT about "classes of Deciders" pair with a "Class of
>> Inputs".
>>
>> The quesiton is about ONE SPECIFIC INPUT, and the answer that ONE
>> SPECIFIC decider gives.
>>
>> You are just proving you just don't know what you are talking about.
>>
>>>
>>>> built on it will halt, then this H(D,D) did not NEED to abort it,
>>>> but did.
>>>>
>>>>
>>>>>
>>>>>>>
>>>>>>>> Since H is supposed to be a "Halt Decider", the HALTING PROPERTY
>>>>>>>> of the input is a very important and relevent fact.
>>>>>>>>
>>>>>>>> I guess you think TRUTH isn't relevent, only whether you can
>>>>>>>> make a convincing lie.
>>>>>>>>
>>>>>>>>> Milk and Cheese and not the same yet both are dairy products.
>>>>>>>>
>>>>>>>> And Milk is a liquid and Cheese is a solid.
>>>>>>>>
>>>>>>>> Try to make a glass og "Chocolate Cheese"
>>>>>>>>
>>>>>>>> Or make a Pizza with "Milk" as a topping.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> There is no reason to assume that ANY X are correct, that is
>>>>>>>>>> your INCORRECT assumption,
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> All H that never halt have incorrect halting behavior for a
>>>>>>>>> decider.
>>>>>>>>> All H that halt have correct halting behavior for a decider.
>>>>>>>>
>>>>>>>> That may make them DECIDERS, but not a HALT DECIDER if they say
>>>>>>>> non-halting for an input you have admitted is Halting.
>>>>>>>>
>>>>>>>> You are just PROVING that you are just a pathetic hypocritical
>>>>>>>> ignorant pathological lying idiot.
>>>>>>>>
>>>>>>>
>>>>>>> Are you willing to bet your soul on that?
>>>>>>
>>>>>> Sure, are YOU?
>>>>>
>>>>> I know that my soul is the one thing that I cannot afford
>>>>> to lose, and what the Hell would I do with two souls when I win?
>>>>> I would not bet my soul that 2 + 3 = 5.
>>>>
>>>> Seems you have already lost it.
>>>>
>>>> And you or I will not be the one to collect.
>>>>
>>> I don't believe that because a woman lied about her weight
>>> by one pound one time that she will
>>
>> No, and that isn't what a "Liar" is, the word means someone whose life
>> is characterized by falsehoods. (like yours)
>>
>>>
>>> *Revelation 21:8 NRSV*
>>> ...and all liars, their place will be in the lake that burns with
>>> fire and sulphur, which is the second death.’
>>
>> Right, but you need to look at the context, HIS PEOPLE are not in that
>> group, and I know that my name is in the
>>
>>>
>>> I also know that God <is> Love and God <has> Wrath is impossibly
>>> true. It is the same as H2O <is> water and H2O <has> Carbon.
>>> *I go by what makes the most sense*
>>
>> And that just shows that you do not know him.
>>
>> So, you WILL find that you will end in that lake of fire.
>>
>>>
>>> What seems to make the most sense is that we concatenate
>>> "with as much empathy as possible" to the commandment to
>>> "love one another" and abolish the distraction of all of the
>>> other commandments so that we can unite in a single-minded
>>> focus on loving others.
>>
>> And all the other DERIVE from this, so they are not "abolished", but
>> expalined.
>>
>
> Not shaving your sideburns is not derived from this.

On 3/27/2024 7:48 PM, Richard Damon wrote:
> On 3/26/24 11:47 PM, olcott wrote:
>> On 3/26/2024 9:18 PM, Richard Damon wrote:
>>> On 3/26/24 11:13 AM, olcott wrote:
>>>> On 3/26/2024 6:39 AM, Richard Damon wrote:
>>>>> On 3/25/24 11:34 PM, olcott wrote:
>>>>>> On 3/25/2024 10:06 PM, Richard Damon wrote:
>>>>>>> On 3/25/24 10:57 PM, olcott wrote:
>>>>
>>>> <snip>
>>>>
>>>>>>>> I am saying that H/D pairs where H simulates D that this D right
>>>>>>>> here
>>>>>>>> not some other D somewhere else never reaches its own line 06.
>>>>>>>
>>>>>>> Right. But that doesn't prove that the D is non-halting of H
>>>>>>> gives up on its simulation.
>>>>>>>
>>>>>>
>>>>>> You always use the strawman deception on this.
>>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>>
>>>>> And you have agreed that an "Abort Deciders" will decide based on
>>>>> if THIS DECIDER needs to abort THIS 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 }
>>>>
>>>> This decider must abort this input when-so-ever this H/D pair is in
>>>> the set of H/D pairs where H simulates its input and D is defined as
>>>> specified above.
>>>
>>> H must do what H does.
>>>
>>> First note, you have strayed from the actual definiton of the
>>> problem, (andthus are LYING about following it) because the specific
>>> D was DEFINED to use a specific COPY of the one decider it was
>>> designed to refute.
>>>
>>> Your D ends up failing to even be a Computation, (when you limit the
>>> desciption of D to NOT include H) because its behavior is NOT fully
>>> defined.
>>>
>>> Yes, any H that doesn't happen to abort its simulation is not a
>>> correct decider because it will fail to decide.
>>>
>>> That DOESN'T mean that an H that does abort is correct, as every
>>> different H that is called by D creates a different behavior for D,
>>> and in effect, creates a "new" D, even though its description (by
>>> your stipulation) is the same, but that is because you have created a
>>> non-computation input, and for those, to determine there behavior, we
>>> need to include the appropriate extra "hidden" information, which in
>>> this case is the code of H.
>>>
>>> Now, if H does abort and return 0, then it is clear that that makes a
>>> D(D) that will halt, as can be proved by having main call UTM(D,D)
>>> with that D still refering to that original H (which you keep on
>>> trying to lie about not being able to do).
>>>
>>> Sincd that simulation will reach an end, then it is shown that these
>>> Hs don't actually NEED to abort, even though (or because of the fact)
>>> they do.
>>>
>>> You can claim this make this an invalid question, and I would agree,
>>> because your D was built wrong. Build D the RIGHT way, with its own
>>> copy of H (that is fixed to be the H you finally decide on, and
>>> doesn't change during your argument) then the question is valid, and
>>> the H that D was built on is clearly wrong, and any other decider
>>> could have its own "pathelogical" input defined that makes IT wrong.
>>>
>>>>
>>>>>  based on if an actual CORRECT SIMULATION of THIS INPUT will run
>>>>> forever or Halt.
>>>>>
>>>>> You are stuck with that definition if you want your "abort
>>>>> deciders" to be at all related to "Halt Deciders", which since you
>>>>> continue to refer to the Halting problem proofs, you do, you need
>>>>> to use THAT definition.
>>>>>
>>>>> Any definition based on looking at the behavior of some other
>>>>> machine and input, is just illogical, but then, you have shown that
>>>>> you thinking goes to illogical ideas.
>>>>>
>>>>
>>>> By that same reasoning cats have no common attributes and some cats
>>>> might bark and some cats might fly because not all cats are exactly
>>>> the same.
>>>
>>> Not *NO* common attributes, but have some differences, so if you
>>> thing being looked at varies, then not all cat are the same.
>>>
>>> For instance, not all cats are black.
>>>
>>> You just don't seem to understand the nature of "Categories"
>>>
>>>>
>>>>>>
>>>>>>> If that was all that was needed, ALL inputs could be correctly
>>>>>>> decided as non-halting.
>>>>>>>
>>>>>>
>>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>>> WE ARE TALKING ABOUT ABORT DECIDERS
>>>>>
>>>>> Right, based on the actual NEED for THIS decider to abort for this
>>>>> exact input.
>>>>>
>>>>
>>>> This decider must abort this input when-so-ever this H/D pair is in
>>>> the set of H/D pairs where H simulates its input and D is defined as
>>>> specified above.
>>>
>>> It must abort to be a decider.
>>>
>>> Thst doesn't mean that if it does abort, it knows the right answer to
>>> the question about the input halting (or needing to be aborted).
>>>
>>> They are NOT the same criteria,
>>>
>>>>
>>>>> Since, for our H(D,D) that is programmed to abort and return 0, the
>>>>> D(D)
>>>>
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>> I never said that, about abort deciders I only said that H simulates D.
>>>
>>> So, are you talking about the ones that do abort, or the ones that
>>> don't.
>>>
>>> You DO understand that these are DIFFERENT programs, and each must be
>>> looked at individually.
>>>
>>> The question is NOT about "classes of Deciders" pair with a "Class of
>>> Inputs".
>>>
>>> The quesiton is about ONE SPECIFIC INPUT, and the answer that ONE
>>> SPECIFIC decider gives.
>>>
>>> You are just proving you just don't know what you are talking about.
>>>
>>>>
>>>>> built on it will halt, then this H(D,D) did not NEED to abort it,
>>>>> but did.
>>>>>
>>>>>
>>>>>>
>>>>>>>>
>>>>>>>>> Since H is supposed to be a "Halt Decider", the HALTING
>>>>>>>>> PROPERTY of the input is a very important and relevent fact.
>>>>>>>>>
>>>>>>>>> I guess you think TRUTH isn't relevent, only whether you can
>>>>>>>>> make a convincing lie.
>>>>>>>>>
>>>>>>>>>> Milk and Cheese and not the same yet both are dairy products.
>>>>>>>>>
>>>>>>>>> And Milk is a liquid and Cheese is a solid.
>>>>>>>>>
>>>>>>>>> Try to make a glass og "Chocolate Cheese"
>>>>>>>>>
>>>>>>>>> Or make a Pizza with "Milk" as a topping.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> There is no reason to assume that ANY X are correct, that is
>>>>>>>>>>> your INCORRECT assumption,
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> All H that never halt have incorrect halting behavior for a
>>>>>>>>>> decider.
>>>>>>>>>> All H that halt have correct halting behavior for a decider.
>>>>>>>>>
>>>>>>>>> That may make them DECIDERS, but not a HALT DECIDER if they say
>>>>>>>>> non-halting for an input you have admitted is Halting.
>>>>>>>>>
>>>>>>>>> You are just PROVING that you are just a pathetic hypocritical
>>>>>>>>> ignorant pathological lying idiot.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Are you willing to bet your soul on that?
>>>>>>>
>>>>>>> Sure, are YOU?
>>>>>>
>>>>>> I know that my soul is the one thing that I cannot afford
>>>>>> to lose, and what the Hell would I do with two souls when I win?
>>>>>> I would not bet my soul that 2 + 3 = 5.
>>>>>
>>>>> Seems you have already lost it.
>>>>>
>>>>> And you or I will not be the one to collect.
>>>>>
>>>> I don't believe that because a woman lied about her weight
>>>> by one pound one time that she will
>>>
>>> No, and that isn't what a "Liar" is, the word means someone whose
>>> life is characterized by falsehoods. (like yours)
>>>
>>>>
>>>> *Revelation 21:8 NRSV*
>>>> ...and all liars, their place will be in the lake that burns with
>>>> fire and sulphur, which is the second death.’
>>>
>>> Right, but you need to look at the context, HIS PEOPLE are not in
>>> that group, and I know that my name is in the
>>>
>>>>
>>>> I also know that God <is> Love and God <has> Wrath is impossibly
>>>> true. It is the same as H2O <is> water and H2O <has> Carbon.
>>>> *I go by what makes the most sense*
>>>
>>> And that just shows that you do not know him.
>>>
>>> So, you WILL find that you will end in that lake of fire.
>>>
>>>>
>>>> What seems to make the most sense is that we concatenate
>>>> "with as much empathy as possible" to the commandment to
>>>> "love one another" and abolish the distraction of all of the
>>>> other commandments so that we can unite in a single-minded
>>>> focus on loving others.
>>>
>>> And all the other DERIVE from this, so they are not "abolished", but
>>> expalined.
>>>
>>
>> Not shaving your sideburns is not derived from this.
>
> How do you know this?
>
> And where do you see a rule about "Sideburns?"
>