On 3/26/2024 6:43 AM, Richard Damon wrote:
> On 3/25/24 11:29 PM, olcott wrote:
>> On 3/25/2024 10:01 PM, Richard Damon wrote:
>>> On 3/25/24 10:53 PM, olcott wrote:
>>>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>>>> On 3/25/24 9:35 PM, olcott wrote:
>>>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott:
>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott:
>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott:
>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot be
>>>>>>>>>>>>>>>>>>>> fooled by any pathological input?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Of all of the elements of the set of H(D,D) where H
>>>>>>>>>>>>>>>>>>>> simulates its
>>>>>>>>>>>>>>>>>>>> input there are matched pairs of otherwise identical
>>>>>>>>>>>>>>>>>>>> elements that
>>>>>>>>>>>>>>>>>>>> only differ by whether they abort their simulation
>>>>>>>>>>>>>>>>>>>> or not.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The half of these that don't abort are incorrect
>>>>>>>>>>>>>>>>>>>> because all deciders
>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct about
>>>>>>>>>>>>>>>>>>>> the abort/no abort
>>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No. The other, aborting, half is just wrong, because
>>>>>>>>>>>>>>>>>>> it aborts when it is not needed. So, the half that
>>>>>>>>>>>>>>>>>>> aborts is wrong and it may be argued that it is
>>>>>>>>>>>>>>>>>>> better to not abort something that halts on its own
>>>>>>>>>>>>>>>>>>> and that
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> At least two software engineers with masters degrees
>>>>>>>>>>>>>>>>>> in computer science
>>>>>>>>>>>>>>>>>> disagree.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Two is not many, considering that with Google for any
>>>>>>>>>>>>>>>>> invalid idea it is easy to find a several people with a
>>>>>>>>>>>>>>>>> master degree supporting it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Exactly what are you software engineering skills?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have been professionally programming since 1986 in
>>>>>>>>>>>>>>>>> several languages. (Non professionally I started
>>>>>>>>>>>>>>>>> programming in 1975). Since about 1990 I programmed in
>>>>>>>>>>>>>>>>> C and since about 2000 in C++.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have been a professional C++ software engineer since
>>>>>>>>>>>>>>>>>> Y2K.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I'm sorry to hear that olcott has been so smart, but
>>>>>>>>>>>>>>>>> now he does not even sees what even a beginner sees.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Even a beginner sees that, if the H that aborts is
>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false (unless
>>>>>>>>>>>>>>> aborted). So simulated D halts (unless aborted).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>> The D simulated by any implementation of H (that aborts or
>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>> abort its simulation) shown above cannot possibly reach
>>>>>>>>>>>>>> its own line 04
>>>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>>>
>>>>>>>>>>> But you agreed that a correct abort decider oly NEEDS to
>>>>>>>>>>> abort its simulation if the correct simulation by a pure
>>>>>>>>>>> correct simulator of the input given to H (which doesn't
>>>>>>>>>>> change, so for this case, still calls that original H) will
>>>>>>>>>>> never reach a final state.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> The question is does that machine described by the input
>>>>>>>>>>>>> Halt when run, or, alternatively, does its correct
>>>>>>>>>>>>> simulation (not just by H) run forever (and thus needs to
>>>>>>>>>>>>> be aborted)?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Since you know that H(D,D) must abort its simulation to
>>>>>>>>>>>> prevent its
>>>>>>>>>>>> own infinite execution I don't understand why you would lie
>>>>>>>>>>>> about it.
>>>>>>>>>>>
>>>>>>>>>>> But an H that doesn't abort and an H that does abort are
>>>>>>>>>>> looking at different inputs "D", since you agree that the
>>>>>>>>>>> behavior of D changes based on the H that it is using.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Not at all. Of the infinite set of every possible
>>>>>>>>>> implementation of
>>>>>>>>>> H where H(D,D) simulates its input everyone that chose to
>>>>>>>>>> abort is
>>>>>>>>>> necessarily correct.
>>>>>>>>>>
>>>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I really want to get on to the next step and see if any
>>>>>>>>>>>> input can
>>>>>>>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>>>>>>>
>>>>>>>>>>> But you need to get this step right first.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Perhaps you already know that you are not up to this challenge?
>>>>>>>>>>>
>>>>>>>>>>> No, it seems that YOU are not up to it, as you can't seem to
>>>>>>>>>>> understand the error that you are making.
>>>>>>>>>>>
>>>>>>>>>>> You keep on lying to yourself about what your requirements are.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am not the one that keeps using the strawman deception to
>>>>>>>>>> change
>>>>>>>>>> the subject away from H(D,D) an abort decider for the above D.
>>>>>>>>>
>>>>>>>>> Neither am I.
>>>>>>>>>
>>>>>>>>> YOU agreed that the criteria for an abort decider is only
>>>>>>>>> CORRECT if a CORRECT simulation of the exact input given to
>>>>>>>>> H(D,D) (i.e UTM(D,D) ) does not halt, where D still calls that
>>>>>>>>> H(D,D)
>>>>>>>>>
>>>>>>>>
>>>>>>>> I never agreed to that.
>>>>>>>
>>>>>>> Yes you did:
>>>>
>>>> *You just admitted to lying abut this* (see below).
>>>
>>> Nope, see below.
>>>
>>>>
>>>>>>>
>>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>  >> To me, for H to NEED to abort its simulation, that means that
>>>>>>> when giving the input to a correct simulator, that simulator will
>>>>>>> not halt.
>>>>>>>  >>
>>>>>>>  > Yes that is correct.
>>>>>>>  >
>>>>>>>
>>>>>>> Since the ONLY definition of a "Correct Simulator" is a simulator
>>>>>>> that never aborts, you did..
>>>>>>>
>>>>>>
>>>>>> Because we have been over this hundreds of times you know that I mean
>>>>>> that a correct simulator means that every step that H simulates was
>>>>>> correctly simulated, so why are you lying about this now?
>>>>>>
>>>>>> Are you trying to run out the clock on my rebuttals?
>>>>>>
>>>>>
>>>>> And YOU know that when *I* say "Correct Simulation", I mean per the
>>>>> definition of a UTM that exactly duplicates the full behavior of
>>>>> the input machine, and you agreed to ME.
>>>>>
>>>>
>>>> Then you are admitting that you lied when you claimed that
>>>> I believed that.
>>>
>>> YOU agreed with what *I* said. When I speak, words mean what *I* hold
>>> them to beleive.
>>>
>>
>> Are you really willing to bet your soul on that?
>
> As I said, YES, but are you?
>
Seems foolish to me. I never bet what I cannot afford to lose.
Maybe you should ask the leadership of your church about this.

On 3/26/2024 3:59 AM, Fred. Zwarts wrote:
> Op 25.mrt.2024 om 18:33 schreef olcott:
>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>> Op 25.mrt.2024 om 17:04 schreef olcott:
>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
>>>>> Op 25.mrt.2024 om 16:17 schreef olcott:
>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott:
>>>>>>>> Can an abort decider be defined that cannot be fooled by any
>>>>>>>> pathological input?
>>>>>>>>
>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 04   if (Halt_Status)
>>>>>>>> 05     HERE: goto HERE;
>>>>>>>> 06   return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11   H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>> Of all of the elements of the set of H(D,D) where H simulates its
>>>>>>>> input there are matched pairs of otherwise identical elements that
>>>>>>>> only differ by whether they abort their simulation or not.
>>>>>>>>
>>>>>>>> The half of these that don't abort are incorrect because all
>>>>>>>> deciders
>>>>>>>> must halt. This makes the other half correct about the abort/no
>>>>>>>> abort
>>>>>>>> decision.
>>>>>>>
>>>>>>> No. The other, aborting, half is just wrong, because it aborts
>>>>>>> when it is not needed. So, the half that aborts is wrong and it
>>>>>>> may be argued that it is better to not abort something that halts
>>>>>>> on its own and that
>>>>>>
>>>>>> At least two software engineers with masters degrees in computer
>>>>>> science
>>>>>> disagree.
>>>>>
>>>>> Two is not many, considering that with Google for any invalid idea
>>>>> it is easy to find a several people with a master degree supporting
>>>>> it.
>>>>>
>>>>>> Exactly what are you software engineering skills?
>>>>>
>>>>> I have been professionally programming since 1986 in several
>>>>> languages. (Non professionally I started programming in 1975).
>>>>> Since about 1990 I programmed in C and since about 2000 in C++.
>>>>>
>>>>>
>>>>>> I have been a professional C++ software engineer since Y2K.
>>>>>
>>>>> I'm sorry to hear that olcott has been so smart, but now he does
>>>>> not even sees what even a beginner sees.
>>>>
>>>> Can D correctly simulated by H terminate normally?
>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>> 02 {
>>>> 03   int Halt_Status = H(x, x);
>>>> 04   if (Halt_Status)
>>>> 05     HERE: goto HERE;
>>>> 06   return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11   H(D,D);
>>>> 12 }
>>>>
>>>> *Execution Trace*
>>>> Line 11: main() invokes H(D,D);
>>>>
>>>> *keeps repeating* (unless aborted)
>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> Even a beginner sees that, if the H that aborts is chosen, simulated
>>> H(D,D) aborts and returns false (unless aborted). So simulated D
>>> halts (unless aborted).
>>>
>>
>> I am estimating that you must be fibbing about your programming skill.
>> The D simulated by any implementation of H (that aborts or does not
>> abort its simulation) shown above cannot possibly reach its own line 04
>> also shown above.
>

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

Can D correctly simulated by H terminate normally?
01 int D(ptr x) // ptr is pointer to int function
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }

*Execution Trace*
Line 11: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

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

Prove your own ignorance or deception by trying to find one mistake in
the above.

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

On 3/26/24 11:33 AM, olcott wrote:
> On 3/26/2024 6:43 AM, Richard Damon wrote:
>> On 3/25/24 11:29 PM, olcott wrote:
>>> On 3/25/2024 10:01 PM, Richard Damon wrote:
>>>> On 3/25/24 10:53 PM, olcott wrote:
>>>>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>>>>> On 3/25/24 9:35 PM, olcott wrote:
>>>>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott:
>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott:
>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot be
>>>>>>>>>>>>>>>>>>>>> fooled by any pathological input?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Of all of the elements of the set of H(D,D) where H
>>>>>>>>>>>>>>>>>>>>> simulates its
>>>>>>>>>>>>>>>>>>>>> input there are matched pairs of otherwise
>>>>>>>>>>>>>>>>>>>>> identical elements that
>>>>>>>>>>>>>>>>>>>>> only differ by whether they abort their simulation
>>>>>>>>>>>>>>>>>>>>> or not.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The half of these that don't abort are incorrect
>>>>>>>>>>>>>>>>>>>>> because all deciders
>>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct about
>>>>>>>>>>>>>>>>>>>>> the abort/no abort
>>>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No. The other, aborting, half is just wrong, because
>>>>>>>>>>>>>>>>>>>> it aborts when it is not needed. So, the half that
>>>>>>>>>>>>>>>>>>>> aborts is wrong and it may be argued that it is
>>>>>>>>>>>>>>>>>>>> better to not abort something that halts on its own
>>>>>>>>>>>>>>>>>>>> and that
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> At least two software engineers with masters degrees
>>>>>>>>>>>>>>>>>>> in computer science
>>>>>>>>>>>>>>>>>>> disagree.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Two is not many, considering that with Google for any
>>>>>>>>>>>>>>>>>> invalid idea it is easy to find a several people with
>>>>>>>>>>>>>>>>>> a master degree supporting it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Exactly what are you software engineering skills?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have been professionally programming since 1986 in
>>>>>>>>>>>>>>>>>> several languages. (Non professionally I started
>>>>>>>>>>>>>>>>>> programming in 1975). Since about 1990 I programmed in
>>>>>>>>>>>>>>>>>> C and since about 2000 in C++.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have been a professional C++ software engineer
>>>>>>>>>>>>>>>>>>> since Y2K.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I'm sorry to hear that olcott has been so smart, but
>>>>>>>>>>>>>>>>>> now he does not even sees what even a beginner sees.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Even a beginner sees that, if the H that aborts is
>>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false
>>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless aborted).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>> The D simulated by any implementation of H (that aborts
>>>>>>>>>>>>>>> or does not
>>>>>>>>>>>>>>> abort its simulation) shown above cannot possibly reach
>>>>>>>>>>>>>>> its own line 04
>>>>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>>>>
>>>>>>>>>>>> But you agreed that a correct abort decider oly NEEDS to
>>>>>>>>>>>> abort its simulation if the correct simulation by a pure
>>>>>>>>>>>> correct simulator of the input given to H (which doesn't
>>>>>>>>>>>> change, so for this case, still calls that original H) will
>>>>>>>>>>>> never reach a final state.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>> The question is does that machine described by the input
>>>>>>>>>>>>>> Halt when run, or, alternatively, does its correct
>>>>>>>>>>>>>> simulation (not just by H) run forever (and thus needs to
>>>>>>>>>>>>>> be aborted)?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since you know that H(D,D) must abort its simulation to
>>>>>>>>>>>>> prevent its
>>>>>>>>>>>>> own infinite execution I don't understand why you would lie
>>>>>>>>>>>>> about it.
>>>>>>>>>>>>
>>>>>>>>>>>> But an H that doesn't abort and an H that does abort are
>>>>>>>>>>>> looking at different inputs "D", since you agree that the
>>>>>>>>>>>> behavior of D changes based on the H that it is using.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Not at all. Of the infinite set of every possible
>>>>>>>>>>> implementation of
>>>>>>>>>>> H where H(D,D) simulates its input everyone that chose to
>>>>>>>>>>> abort is
>>>>>>>>>>> necessarily correct.
>>>>>>>>>>>
>>>>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I really want to get on to the next step and see if any
>>>>>>>>>>>>> input can
>>>>>>>>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>>>>>>>>
>>>>>>>>>>>> But you need to get this step right first.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Perhaps you already know that you are not up to this
>>>>>>>>>>>>> challenge?
>>>>>>>>>>>>
>>>>>>>>>>>> No, it seems that YOU are not up to it, as you can't seem to
>>>>>>>>>>>> understand the error that you are making.
>>>>>>>>>>>>
>>>>>>>>>>>> You keep on lying to yourself about what your requirements are.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I am not the one that keeps using the strawman deception to
>>>>>>>>>>> change
>>>>>>>>>>> the subject away from H(D,D) an abort decider for the above D.
>>>>>>>>>>
>>>>>>>>>> Neither am I.
>>>>>>>>>>
>>>>>>>>>> YOU agreed that the criteria for an abort decider is only
>>>>>>>>>> CORRECT if a CORRECT simulation of the exact input given to
>>>>>>>>>> H(D,D) (i.e UTM(D,D) ) does not halt, where D still calls that
>>>>>>>>>> H(D,D)
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I never agreed to that.
>>>>>>>>
>>>>>>>> Yes you did:
>>>>>
>>>>> *You just admitted to lying abut this* (see below).
>>>>
>>>> Nope, see below.
>>>>
>>>>>
>>>>>>>>
>>>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>  >> To me, for H to NEED to abort its simulation, that means
>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>> simulator will not halt.
>>>>>>>>  >>
>>>>>>>>  > Yes that is correct.
>>>>>>>>  >
>>>>>>>>
>>>>>>>> Since the ONLY definition of a "Correct Simulator" is a
>>>>>>>> simulator that never aborts, you did..
>>>>>>>>
>>>>>>>
>>>>>>> Because we have been over this hundreds of times you know that I
>>>>>>> mean
>>>>>>> that a correct simulator means that every step that H simulates was
>>>>>>> correctly simulated, so why are you lying about this now?
>>>>>>>
>>>>>>> Are you trying to run out the clock on my rebuttals?
>>>>>>>
>>>>>>
>>>>>> And YOU know that when *I* say "Correct Simulation", I mean per
>>>>>> the definition of a UTM that exactly duplicates the full behavior
>>>>>> of the input machine, and you agreed to ME.
>>>>>>
>>>>>
>>>>> Then you are admitting that you lied when you claimed that
>>>>> I believed that.
>>>>
>>>> YOU agreed with what *I* said. When I speak, words mean what *I*
>>>> hold them to beleive.
>>>>
>>>
>>> Are you really willing to bet your soul on that?
>>
>> As I said, YES, but are you?
>>
> Seems foolish to me. I never bet what I cannot afford to lose.
> Maybe you should ask the leadership of your church about this.

On 3/26/2024 9:18 PM, Richard Damon wrote:
> On 3/26/24 11:33 AM, olcott wrote:
>> On 3/26/2024 6:43 AM, Richard Damon wrote:
>>> On 3/25/24 11:29 PM, olcott wrote:
>>>> On 3/25/2024 10:01 PM, Richard Damon wrote:
>>>>> On 3/25/24 10:53 PM, olcott wrote:
>>>>>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>>>>>> On 3/25/24 9:35 PM, olcott wrote:
>>>>>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott:
>>>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott:
>>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot be
>>>>>>>>>>>>>>>>>>>>>> fooled by any pathological input?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Of all of the elements of the set of H(D,D) where
>>>>>>>>>>>>>>>>>>>>>> H simulates its
>>>>>>>>>>>>>>>>>>>>>> input there are matched pairs of otherwise
>>>>>>>>>>>>>>>>>>>>>> identical elements that
>>>>>>>>>>>>>>>>>>>>>> only differ by whether they abort their simulation
>>>>>>>>>>>>>>>>>>>>>> or not.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The half of these that don't abort are incorrect
>>>>>>>>>>>>>>>>>>>>>> because all deciders
>>>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct about
>>>>>>>>>>>>>>>>>>>>>> the abort/no abort
>>>>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No. The other, aborting, half is just wrong,
>>>>>>>>>>>>>>>>>>>>> because it aborts when it is not needed. So, the
>>>>>>>>>>>>>>>>>>>>> half that aborts is wrong and it may be argued that
>>>>>>>>>>>>>>>>>>>>> it is better to not abort something that halts on
>>>>>>>>>>>>>>>>>>>>> its own and that
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> At least two software engineers with masters degrees
>>>>>>>>>>>>>>>>>>>> in computer science
>>>>>>>>>>>>>>>>>>>> disagree.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Two is not many, considering that with Google for any
>>>>>>>>>>>>>>>>>>> invalid idea it is easy to find a several people with
>>>>>>>>>>>>>>>>>>> a master degree supporting it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Exactly what are you software engineering skills?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have been professionally programming since 1986 in
>>>>>>>>>>>>>>>>>>> several languages. (Non professionally I started
>>>>>>>>>>>>>>>>>>> programming in 1975). Since about 1990 I programmed
>>>>>>>>>>>>>>>>>>> in C and since about 2000 in C++.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I have been a professional C++ software engineer
>>>>>>>>>>>>>>>>>>>> since Y2K.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I'm sorry to hear that olcott has been so smart, but
>>>>>>>>>>>>>>>>>>> now he does not even sees what even a beginner sees.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Even a beginner sees that, if the H that aborts is
>>>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false
>>>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless aborted).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>>> The D simulated by any implementation of H (that aborts
>>>>>>>>>>>>>>>> or does not
>>>>>>>>>>>>>>>> abort its simulation) shown above cannot possibly reach
>>>>>>>>>>>>>>>> its own line 04
>>>>>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>>>>>
>>>>>>>>>>>>> But you agreed that a correct abort decider oly NEEDS to
>>>>>>>>>>>>> abort its simulation if the correct simulation by a pure
>>>>>>>>>>>>> correct simulator of the input given to H (which doesn't
>>>>>>>>>>>>> change, so for this case, still calls that original H) will
>>>>>>>>>>>>> never reach a final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The question is does that machine described by the input
>>>>>>>>>>>>>>> Halt when run, or, alternatively, does its correct
>>>>>>>>>>>>>>> simulation (not just by H) run forever (and thus needs to
>>>>>>>>>>>>>>> be aborted)?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since you know that H(D,D) must abort its simulation to
>>>>>>>>>>>>>> prevent its
>>>>>>>>>>>>>> own infinite execution I don't understand why you would
>>>>>>>>>>>>>> lie about it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But an H that doesn't abort and an H that does abort are
>>>>>>>>>>>>> looking at different inputs "D", since you agree that the
>>>>>>>>>>>>> behavior of D changes based on the H that it is using.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Not at all. Of the infinite set of every possible
>>>>>>>>>>>> implementation of
>>>>>>>>>>>> H where H(D,D) simulates its input everyone that chose to
>>>>>>>>>>>> abort is
>>>>>>>>>>>> necessarily correct.
>>>>>>>>>>>>
>>>>>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I really want to get on to the next step and see if any
>>>>>>>>>>>>>> input can
>>>>>>>>>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But you need to get this step right first.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Perhaps you already know that you are not up to this
>>>>>>>>>>>>>> challenge?
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, it seems that YOU are not up to it, as you can't seem
>>>>>>>>>>>>> to understand the error that you are making.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You keep on lying to yourself about what your requirements
>>>>>>>>>>>>> are.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I am not the one that keeps using the strawman deception to
>>>>>>>>>>>> change
>>>>>>>>>>>> the subject away from H(D,D) an abort decider for the above D.
>>>>>>>>>>>
>>>>>>>>>>> Neither am I.
>>>>>>>>>>>
>>>>>>>>>>> YOU agreed that the criteria for an abort decider is only
>>>>>>>>>>> CORRECT if a CORRECT simulation of the exact input given to
>>>>>>>>>>> H(D,D) (i.e UTM(D,D) ) does not halt, where D still calls
>>>>>>>>>>> that H(D,D)
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I never agreed to that.
>>>>>>>>>
>>>>>>>>> Yes you did:
>>>>>>
>>>>>> *You just admitted to lying abut this* (see below).
>>>>>
>>>>> Nope, see below.
>>>>>
>>>>>>
>>>>>>>>>
>>>>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>  >> To me, for H to NEED to abort its simulation, that means
>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>> simulator will not halt.
>>>>>>>>>  >>
>>>>>>>>>  > Yes that is correct.
>>>>>>>>>  >
>>>>>>>>>
>>>>>>>>> Since the ONLY definition of a "Correct Simulator" is a
>>>>>>>>> simulator that never aborts, you did..
>>>>>>>>>
>>>>>>>>
>>>>>>>> Because we have been over this hundreds of times you know that I
>>>>>>>> mean
>>>>>>>> that a correct simulator means that every step that H simulates was
>>>>>>>> correctly simulated, so why are you lying about this now?
>>>>>>>>
>>>>>>>> Are you trying to run out the clock on my rebuttals?
>>>>>>>>
>>>>>>>
>>>>>>> And YOU know that when *I* say "Correct Simulation", I mean per
>>>>>>> the definition of a UTM that exactly duplicates the full behavior
>>>>>>> of the input machine, and you agreed to ME.
>>>>>>>
>>>>>>
>>>>>> Then you are admitting that you lied when you claimed that
>>>>>> I believed that.
>>>>>
>>>>> YOU agreed with what *I* said. When I speak, words mean what *I*
>>>>> hold them to beleive.
>>>>>
>>>>
>>>> Are you really willing to bet your soul on that?
>>>
>>> As I said, YES, but are you?
>>>
>> Seems foolish to me. I never bet what I cannot afford to lose.
>> Maybe you should ask the leadership of your church about this.
>
> But I know I can't lose, because I know of the promise of God and that
> he has written my name in his Book of Life.
>
>>
>>> Or does the fact that you already lost it mean it doesn't matter to you.
>>>
>> That is not what scripture says.
>
> It does, but you do not understand it.
>
> You seem to have reached the point where God has turned you over to your
> own desires, giving you the taste of eternal hell here, to see if you
> will repent.
>
> If you do, you can claim your soul back, but for now, YOU have given it
> to the devil.
>

On 3/26/24 11:10 PM, olcott wrote:
> On 3/26/2024 9:18 PM, Richard Damon wrote:
>> On 3/26/24 11:33 AM, olcott wrote:
>>> On 3/26/2024 6:43 AM, Richard Damon wrote:
>>>> On 3/25/24 11:29 PM, olcott wrote:
>>>>> On 3/25/2024 10:01 PM, Richard Damon wrote:
>>>>>> On 3/25/24 10:53 PM, olcott wrote:
>>>>>>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>>>>>>> On 3/25/24 9:35 PM, olcott wrote:
>>>>>>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>>>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott:
>>>>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott:
>>>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot be
>>>>>>>>>>>>>>>>>>>>>>> fooled by any pathological input?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Of all of the elements of the set of H(D,D) where
>>>>>>>>>>>>>>>>>>>>>>> H simulates its
>>>>>>>>>>>>>>>>>>>>>>> input there are matched pairs of otherwise
>>>>>>>>>>>>>>>>>>>>>>> identical elements that
>>>>>>>>>>>>>>>>>>>>>>> only differ by whether they abort their
>>>>>>>>>>>>>>>>>>>>>>> simulation or not.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The half of these that don't abort are incorrect
>>>>>>>>>>>>>>>>>>>>>>> because all deciders
>>>>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct
>>>>>>>>>>>>>>>>>>>>>>> about the abort/no abort
>>>>>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No. The other, aborting, half is just wrong,
>>>>>>>>>>>>>>>>>>>>>> because it aborts when it is not needed. So, the
>>>>>>>>>>>>>>>>>>>>>> half that aborts is wrong and it may be argued
>>>>>>>>>>>>>>>>>>>>>> that it is better to not abort something that
>>>>>>>>>>>>>>>>>>>>>> halts on its own and that
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> At least two software engineers with masters
>>>>>>>>>>>>>>>>>>>>> degrees in computer science
>>>>>>>>>>>>>>>>>>>>> disagree.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Two is not many, considering that with Google for
>>>>>>>>>>>>>>>>>>>> any invalid idea it is easy to find a several people
>>>>>>>>>>>>>>>>>>>> with a master degree supporting it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Exactly what are you software engineering skills?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I have been professionally programming since 1986 in
>>>>>>>>>>>>>>>>>>>> several languages. (Non professionally I started
>>>>>>>>>>>>>>>>>>>> programming in 1975). Since about 1990 I programmed
>>>>>>>>>>>>>>>>>>>> in C and since about 2000 in C++.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I have been a professional C++ software engineer
>>>>>>>>>>>>>>>>>>>>> since Y2K.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I'm sorry to hear that olcott has been so smart, but
>>>>>>>>>>>>>>>>>>>> now he does not even sees what even a beginner sees.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that
>>>>>>>>>>>>>>>>>>> simulates D(D)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Even a beginner sees that, if the H that aborts is
>>>>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false
>>>>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless aborted).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>>>> The D simulated by any implementation of H (that aborts
>>>>>>>>>>>>>>>>> or does not
>>>>>>>>>>>>>>>>> abort its simulation) shown above cannot possibly reach
>>>>>>>>>>>>>>>>> its own line 04
>>>>>>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But you agreed that a correct abort decider oly NEEDS to
>>>>>>>>>>>>>> abort its simulation if the correct simulation by a pure
>>>>>>>>>>>>>> correct simulator of the input given to H (which doesn't
>>>>>>>>>>>>>> change, so for this case, still calls that original H)
>>>>>>>>>>>>>> will never reach a final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The question is does that machine described by the input
>>>>>>>>>>>>>>>> Halt when run, or, alternatively, does its correct
>>>>>>>>>>>>>>>> simulation (not just by H) run forever (and thus needs
>>>>>>>>>>>>>>>> to be aborted)?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since you know that H(D,D) must abort its simulation to
>>>>>>>>>>>>>>> prevent its
>>>>>>>>>>>>>>> own infinite execution I don't understand why you would
>>>>>>>>>>>>>>> lie about it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But an H that doesn't abort and an H that does abort are
>>>>>>>>>>>>>> looking at different inputs "D", since you agree that the
>>>>>>>>>>>>>> behavior of D changes based on the H that it is using.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Not at all. Of the infinite set of every possible
>>>>>>>>>>>>> implementation of
>>>>>>>>>>>>> H where H(D,D) simulates its input everyone that chose to
>>>>>>>>>>>>> abort is
>>>>>>>>>>>>> necessarily correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I really want to get on to the next step and see if any
>>>>>>>>>>>>>>> input can
>>>>>>>>>>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But you need to get this step right first.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Perhaps you already know that you are not up to this
>>>>>>>>>>>>>>> challenge?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, it seems that YOU are not up to it, as you can't seem
>>>>>>>>>>>>>> to understand the error that you are making.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You keep on lying to yourself about what your requirements
>>>>>>>>>>>>>> are.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am not the one that keeps using the strawman deception to
>>>>>>>>>>>>> change
>>>>>>>>>>>>> the subject away from H(D,D) an abort decider for the above D.
>>>>>>>>>>>>
>>>>>>>>>>>> Neither am I.
>>>>>>>>>>>>
>>>>>>>>>>>> YOU agreed that the criteria for an abort decider is only
>>>>>>>>>>>> CORRECT if a CORRECT simulation of the exact input given to
>>>>>>>>>>>> H(D,D) (i.e UTM(D,D) ) does not halt, where D still calls
>>>>>>>>>>>> that H(D,D)
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I never agreed to that.
>>>>>>>>>>
>>>>>>>>>> Yes you did:
>>>>>>>
>>>>>>> *You just admitted to lying abut this* (see below).
>>>>>>
>>>>>> Nope, see below.
>>>>>>
>>>>>>>
>>>>>>>>>>
>>>>>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>  >> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>> simulator will not halt.
>>>>>>>>>>  >>
>>>>>>>>>>  > Yes that is correct.
>>>>>>>>>>  >
>>>>>>>>>>
>>>>>>>>>> Since the ONLY definition of a "Correct Simulator" is a
>>>>>>>>>> simulator that never aborts, you did..
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because we have been over this hundreds of times you know that
>>>>>>>>> I mean
>>>>>>>>> that a correct simulator means that every step that H simulates
>>>>>>>>> was
>>>>>>>>> correctly simulated, so why are you lying about this now?
>>>>>>>>>
>>>>>>>>> Are you trying to run out the clock on my rebuttals?
>>>>>>>>>
>>>>>>>>
>>>>>>>> And YOU know that when *I* say "Correct Simulation", I mean per
>>>>>>>> the definition of a UTM that exactly duplicates the full
>>>>>>>> behavior of the input machine, and you agreed to ME.
>>>>>>>>
>>>>>>>
>>>>>>> Then you are admitting that you lied when you claimed that
>>>>>>> I believed that.
>>>>>>
>>>>>> YOU agreed with what *I* said. When I speak, words mean what *I*
>>>>>> hold them to beleive.
>>>>>>
>>>>>
>>>>> Are you really willing to bet your soul on that?
>>>>
>>>> As I said, YES, but are you?
>>>>
>>> Seems foolish to me. I never bet what I cannot afford to lose.
>>> Maybe you should ask the leadership of your church about this.
>>
>> But I know I can't lose, because I know of the promise of God and that
>> he has written my name in his Book of Life.
>>
>>>
>>>> Or does the fact that you already lost it mean it doesn't matter to
>>>> you.
>>>>
>>> That is not what scripture says.
>>
>> It does, but you do not understand it.
>>
>> You seem to have reached the point where God has turned you over to
>> your own desires, giving you the taste of eternal hell here, to see if
>> you will repent.
>>
>> If you do, you can claim your soul back, but for now, YOU have given
>> it to the devil.
>>

On 3/27/2024 7:48 PM, Richard Damon wrote:
> On 3/26/24 11:10 PM, olcott wrote:
>> On 3/26/2024 9:18 PM, Richard Damon wrote:
>>> On 3/26/24 11:33 AM, olcott wrote:
>>>> On 3/26/2024 6:43 AM, Richard Damon wrote:
>>>>> On 3/25/24 11:29 PM, olcott wrote:
>>>>>> On 3/25/2024 10:01 PM, Richard Damon wrote:
>>>>>>> On 3/25/24 10:53 PM, olcott wrote:
>>>>>>>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>>>>>>>> On 3/25/24 9:35 PM, olcott wrote:
>>>>>>>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>>>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott:
>>>>>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot be
>>>>>>>>>>>>>>>>>>>>>>>> fooled by any pathological input?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Of all of the elements of the set of H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>> where H simulates its
>>>>>>>>>>>>>>>>>>>>>>>> input there are matched pairs of otherwise
>>>>>>>>>>>>>>>>>>>>>>>> identical elements that
>>>>>>>>>>>>>>>>>>>>>>>> only differ by whether they abort their
>>>>>>>>>>>>>>>>>>>>>>>> simulation or not.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The half of these that don't abort are incorrect
>>>>>>>>>>>>>>>>>>>>>>>> because all deciders
>>>>>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct
>>>>>>>>>>>>>>>>>>>>>>>> about the abort/no abort
>>>>>>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No. The other, aborting, half is just wrong,
>>>>>>>>>>>>>>>>>>>>>>> because it aborts when it is not needed. So, the
>>>>>>>>>>>>>>>>>>>>>>> half that aborts is wrong and it may be argued
>>>>>>>>>>>>>>>>>>>>>>> that it is better to not abort something that
>>>>>>>>>>>>>>>>>>>>>>> halts on its own and that
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> At least two software engineers with masters
>>>>>>>>>>>>>>>>>>>>>> degrees in computer science
>>>>>>>>>>>>>>>>>>>>>> disagree.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Two is not many, considering that with Google for
>>>>>>>>>>>>>>>>>>>>> any invalid idea it is easy to find a several
>>>>>>>>>>>>>>>>>>>>> people with a master degree supporting it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Exactly what are you software engineering skills?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I have been professionally programming since 1986
>>>>>>>>>>>>>>>>>>>>> in several languages. (Non professionally I started
>>>>>>>>>>>>>>>>>>>>> programming in 1975). Since about 1990 I programmed
>>>>>>>>>>>>>>>>>>>>> in C and since about 2000 in C++.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I have been a professional C++ software engineer
>>>>>>>>>>>>>>>>>>>>>> since Y2K.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I'm sorry to hear that olcott has been so smart,
>>>>>>>>>>>>>>>>>>>>> but now he does not even sees what even a beginner
>>>>>>>>>>>>>>>>>>>>> sees.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D)
>>>>>>>>>>>>>>>>>>>> that simulates D(D)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Even a beginner sees that, if the H that aborts is
>>>>>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false
>>>>>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless aborted).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>>>>> The D simulated by any implementation of H (that
>>>>>>>>>>>>>>>>>> aborts or does not
>>>>>>>>>>>>>>>>>> abort its simulation) shown above cannot possibly
>>>>>>>>>>>>>>>>>> reach its own line 04
>>>>>>>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But you agreed that a correct abort decider oly NEEDS to
>>>>>>>>>>>>>>> abort its simulation if the correct simulation by a pure
>>>>>>>>>>>>>>> correct simulator of the input given to H (which doesn't
>>>>>>>>>>>>>>> change, so for this case, still calls that original H)
>>>>>>>>>>>>>>> will never reach a final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The question is does that machine described by the
>>>>>>>>>>>>>>>>> input Halt when run, or, alternatively, does its
>>>>>>>>>>>>>>>>> correct simulation (not just by H) run forever (and
>>>>>>>>>>>>>>>>> thus needs to be aborted)?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Since you know that H(D,D) must abort its simulation to
>>>>>>>>>>>>>>>> prevent its
>>>>>>>>>>>>>>>> own infinite execution I don't understand why you would
>>>>>>>>>>>>>>>> lie about it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But an H that doesn't abort and an H that does abort are
>>>>>>>>>>>>>>> looking at different inputs "D", since you agree that the
>>>>>>>>>>>>>>> behavior of D changes based on the H that it is using.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Not at all. Of the infinite set of every possible
>>>>>>>>>>>>>> implementation of
>>>>>>>>>>>>>> H where H(D,D) simulates its input everyone that chose to
>>>>>>>>>>>>>> abort is
>>>>>>>>>>>>>> necessarily correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I really want to get on to the next step and see if any
>>>>>>>>>>>>>>>> input can
>>>>>>>>>>>>>>>> fool an abort decider into making the wrong abort decision.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But you need to get this step right first.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Perhaps you already know that you are not up to this
>>>>>>>>>>>>>>>> challenge?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, it seems that YOU are not up to it, as you can't seem
>>>>>>>>>>>>>>> to understand the error that you are making.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You keep on lying to yourself about what your
>>>>>>>>>>>>>>> requirements are.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am not the one that keeps using the strawman deception
>>>>>>>>>>>>>> to change
>>>>>>>>>>>>>> the subject away from H(D,D) an abort decider for the
>>>>>>>>>>>>>> above D.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Neither am I.
>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU agreed that the criteria for an abort decider is only
>>>>>>>>>>>>> CORRECT if a CORRECT simulation of the exact input given to
>>>>>>>>>>>>> H(D,D) (i.e UTM(D,D) ) does not halt, where D still calls
>>>>>>>>>>>>> that H(D,D)
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I never agreed to that.
>>>>>>>>>>>
>>>>>>>>>>> Yes you did:
>>>>>>>>
>>>>>>>> *You just admitted to lying abut this* (see below).
>>>>>>>
>>>>>>> Nope, see below.
>>>>>>>
>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>  >> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>  >>
>>>>>>>>>>>  > Yes that is correct.
>>>>>>>>>>>  >
>>>>>>>>>>>
>>>>>>>>>>> Since the ONLY definition of a "Correct Simulator" is a
>>>>>>>>>>> simulator that never aborts, you did..
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because we have been over this hundreds of times you know that
>>>>>>>>>> I mean
>>>>>>>>>> that a correct simulator means that every step that H
>>>>>>>>>> simulates was
>>>>>>>>>> correctly simulated, so why are you lying about this now?
>>>>>>>>>>
>>>>>>>>>> Are you trying to run out the clock on my rebuttals?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And YOU know that when *I* say "Correct Simulation", I mean per
>>>>>>>>> the definition of a UTM that exactly duplicates the full
>>>>>>>>> behavior of the input machine, and you agreed to ME.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Then you are admitting that you lied when you claimed that
>>>>>>>> I believed that.
>>>>>>>
>>>>>>> YOU agreed with what *I* said. When I speak, words mean what *I*
>>>>>>> hold them to beleive.
>>>>>>>
>>>>>>
>>>>>> Are you really willing to bet your soul on that?
>>>>>
>>>>> As I said, YES, but are you?
>>>>>
>>>> Seems foolish to me. I never bet what I cannot afford to lose.
>>>> Maybe you should ask the leadership of your church about this.
>>>
>>> But I know I can't lose, because I know of the promise of God and
>>> that he has written my name in his Book of Life.
>>>
>>>>
>>>>> Or does the fact that you already lost it mean it doesn't matter to
>>>>> you.
>>>>>
>>>> That is not what scripture says.
>>>
>>> It does, but you do not understand it.
>>>
>>> You seem to have reached the point where God has turned you over to
>>> your own desires, giving you the taste of eternal hell here, to see
>>> if you will repent.
>>>
>>> If you do, you can claim your soul back, but for now, YOU have given
>>> it to the devil.
>>>
>
> So, you now go and show that you will also LIE about the meaning of
> verses in the Bible.
>
> You are going to show that just as you try to misinterprete the works of
> the great logicitians that have proved things you don't like, you are
> also going to misinterpete the Bible to try to juistify your own ideas.
>
> You are just Proof-Texting and doing Eisogesis on the text, instead of
> Exegesis to discover the actual meaning.
>
>>
>> Galatians 5:14 NRSV
>> For the whole law is summed up in a single commandment,
>> “You shall love your neighbor as yourself.”
>
> Remember, Galatians was written to a CHURCH of BELIEVERS, who were
> suffering some persecution. There was a movement to try to push them
> back to "Old Testament Judiasm", which was a Key part of Paul's
> discourse. Being Beleivers, talking about the need to love God, wasn't
> an issue, but pointing out that the ceremonial law and animal sacrifice
> system was no longer applicable, because it had been fulfilled. The
> MORAL law, which is the part that derives from the "Second Greatest
> Commandment"
>
> From Matthew 22:37 Jesus replied: “ ‘Love the Lord your God with all
> your heart and with all your soul and with all your mind.’ 38 This is
> the first and greatest commandment. And the second is like it: ‘Love
> your neighbor as yourself.’ All the Law and the Prophets hang on these
> two commandments.”
>
> Paul can help interprete Jesus, but can not change his meaning.
>
>>
>> Isaiah 45:6
>> That they may know from the rising of the sun, and from
>> the west, that there is none beside me. I am the Lord, and
>> there is none else.
>>
>> When one takes the above two verses 100% literally as if
>> they were a mathematical specification one gets an entirely
>> different meaning than everyone else gets.
>
> But 100% literal is NOT how you need to take the verses of the Bible.
>
>>
>> I checked the last very with two Hebrew bible scholars and
>> they both agree that it says nothing besides God actually
>> exists.
>
> So? Interpreting a verse out of context is just a pretext.
>
>>
>> All those lead by the Holy Spirit are on the right path. I
>> am doing what I can for additional spiritual confirmation.
>
> I seriously doubt you are being lead by the HOLY Spirit, as he can not
> stand to be with a liar.
>
> OR someone who blasphemes God by claiming to be comparable.
>
> It is likely some other "spirit" guiding you to that lake of fire.
>
>
>>
>>>>
>>>>>>
>>>>>>> Thus, YOU AGREED to MY definition, since you agrees with NO
>>>>>>> qualifications of your statement.
>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> YOU definition is just illogical as it means that the behavior
>>>>>>>>> of a machine is determined by the behavior of a machine that is
>>>>>>>>> not it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Because deciders must always halt every H that never halts has
>>>>>>>> incorrect
>>>>>>>> halting behavior and every H that halts has correct halting
>>>>>>>> behavior.
>>>>>>>
>>>>>>> That isn't what a "Halt Decider" means, and you are just proving
>>>>>>> you are just STUPID.
>>>>>>>
>>>>>>
>>>>>> So now you are disagreeing that ALL deciders must always halt?
>>>>>
>>>>> Nope, but Halting isn't enough to make a foo decider a foo decider.
>>>>>
>>>> Sure I can certainly agree with that.
>>>
>>> So, the fact that you deciders just Halt, doesn't make the correct
>>> Halt Deciders, they are only that if their answer to H(M,d) matchs
>>> Halts(M,d) for all M and d, or for this particular case H(D,D) must
>>> match Halts(D,D), which is doesn't, so they are not correct halt
>>> deciders.
>>>
>>
>> // A is an abort decider
>
>
>
>> 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.
>>
>> When-so-ever a simulating abort decider correctly determines in N
>> steps of correct simulation that the behavior of its input matches
>> a correct predefined non-halting behavior pattern the abort decider
>> is always correct to abort the simulation of this input.
>
> So, does A have a SPECIFIC set of code that it is running?
>
> If not, your whole arguement is just a LIE.
>
> If it does, how can it determine what it would do if it doesn't do what
> it does, that would be something else, not it.
>
> And, since you are defining "B" to use what ever A happens to exist at
> the moment. B isn't a computation or even a program by the normal
> definition of one.
>
> In this case, I would say you are correct to say that THIS problem is
> "invalid", due to the automagically changing input as you change the
> decider looking at it.
>
> Of course, since the REAL Haltng problem doesn't do that, it is still
> valid.
>
>>
>>>>
>>>>> You are just playing with words again.
>>>>>
>>>>> To be a Halt Decider, the output needs to match the Halting Function.
>>>>>
>>>> I will agree that is the common understanding.
>>>> The is no preexisting common understanding of a simulating abort
>>>> decider because (to the best of my knowledge) no one every thought
>>>> of this before.
>>>
>>> And either it is equivalent, or it isn't. If it isn't, then it says
>>> nothing about the Halting Problem.
>>>
>>
>> It is too disingenuous to say that it say nothing about the halting
>> problem. It as much as solves a different version of the halting
>> problem.
>
> Which isn't the Halting Problem. Something that isn't the Halting
> Problem doesn't say much about the actual Halting Problem.
>
> Now, if you want to try to actually formally define your differences,
> and some how show that they are actually minor and insignificant, you
> might be able to do something, but when you throw out fundamental
> principles. liek a program is what the program is, you are just lying
> about what you are doing.
>
>>
>> If the original version is incoherent the same sort of way that Naive
>> set theory allowed Russell's Paradox then an abort decider corrects
>> the erroneous halting problem that same way that ZFC corrected Naive
>> set theory.
>>
>>> Since the only rational definition of "Needs to Abort its
>>> simulation", is that a correct simulation of the input would not
>>> halt, then your "abort deciders" turn out to need to be actually Halt
>>> Decider.
>>>
>>
>> An abort decider <is> a halt decider from its own point of view.
>> It is not and cannot be a halt decider from any other POV.
>
> Only by lying to itself.
>
> Since Halt Deciding is a OBJECTIVE criteria, it can't be equivalent, or
> even very similar to your SUBJECTIVE new criteria, which you can't even
> properly define, since you keep on with your using of non-algorithmic
> terms to describe what it is to do.
>
>>
>>> The logic of looking at what would happen if H was a different
>>> machine ib a way that actually changed the behavior of the input
>>> (because you either make the input not a computation, or re-write the
>>> input) is ust invalid.
>>>
>>
>> The whole class of every H(D,D) that simulates its input
>> is divided into two sub-classes:
>> (a) H(D,D) that DOES NOT abort its simulation is incorrect
>>      (ABOUT THIS ABORT DECISION)
>>      because it would never halt and all deciders must always halt.
>>
>> (b) H(D,D) that DOES abort its simulation is correct
>>      (ABOUT THIS ABORT DECISION)
>>      because it would halt and all deciders must always halt.
>
> So, it is a DECIDER, but you haven't proven it is a CORRECT decider
> about any defined mapping (other than the trivial problem of it maps
> what it generates).
>

On 3/27/24 10:07 PM, olcott wrote:
> On 3/27/2024 7:48 PM, Richard Damon wrote:
>> On 3/26/24 11:10 PM, olcott wrote:
>>> On 3/26/2024 9:18 PM, Richard Damon wrote:
>>>> On 3/26/24 11:33 AM, olcott wrote:
>>>>> On 3/26/2024 6:43 AM, Richard Damon wrote:
>>>>>> On 3/25/24 11:29 PM, olcott wrote:
>>>>>>> On 3/25/2024 10:01 PM, Richard Damon wrote:
>>>>>>>> On 3/25/24 10:53 PM, olcott wrote:
>>>>>>>>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>>>>>>>>> On 3/25/24 9:35 PM, olcott wrote:
>>>>>>>>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>>>>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott:
>>>>>>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot be
>>>>>>>>>>>>>>>>>>>>>>>>> fooled by any pathological input?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Of all of the elements of the set of H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>> where H simulates its
>>>>>>>>>>>>>>>>>>>>>>>>> input there are matched pairs of otherwise
>>>>>>>>>>>>>>>>>>>>>>>>> identical elements that
>>>>>>>>>>>>>>>>>>>>>>>>> only differ by whether they abort their
>>>>>>>>>>>>>>>>>>>>>>>>> simulation or not.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The half of these that don't abort are
>>>>>>>>>>>>>>>>>>>>>>>>> incorrect because all deciders
>>>>>>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct
>>>>>>>>>>>>>>>>>>>>>>>>> about the abort/no abort
>>>>>>>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No. The other, aborting, half is just wrong,
>>>>>>>>>>>>>>>>>>>>>>>> because it aborts when it is not needed. So, the
>>>>>>>>>>>>>>>>>>>>>>>> half that aborts is wrong and it may be argued
>>>>>>>>>>>>>>>>>>>>>>>> that it is better to not abort something that
>>>>>>>>>>>>>>>>>>>>>>>> halts on its own and that
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> At least two software engineers with masters
>>>>>>>>>>>>>>>>>>>>>>> degrees in computer science
>>>>>>>>>>>>>>>>>>>>>>> disagree.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Two is not many, considering that with Google for
>>>>>>>>>>>>>>>>>>>>>> any invalid idea it is easy to find a several
>>>>>>>>>>>>>>>>>>>>>> people with a master degree supporting it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Exactly what are you software engineering skills?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I have been professionally programming since 1986
>>>>>>>>>>>>>>>>>>>>>> in several languages. (Non professionally I
>>>>>>>>>>>>>>>>>>>>>> started programming in 1975). Since about 1990 I
>>>>>>>>>>>>>>>>>>>>>> programmed in C and since about 2000 in C++.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I have been a professional C++ software engineer
>>>>>>>>>>>>>>>>>>>>>>> since Y2K.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I'm sorry to hear that olcott has been so smart,
>>>>>>>>>>>>>>>>>>>>>> but now he does not even sees what even a beginner
>>>>>>>>>>>>>>>>>>>>>> sees.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D)
>>>>>>>>>>>>>>>>>>>>> that simulates D(D)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Even a beginner sees that, if the H that aborts is
>>>>>>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false
>>>>>>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless
>>>>>>>>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>>>>>> The D simulated by any implementation of H (that
>>>>>>>>>>>>>>>>>>> aborts or does not
>>>>>>>>>>>>>>>>>>> abort its simulation) shown above cannot possibly
>>>>>>>>>>>>>>>>>>> reach its own line 04
>>>>>>>>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But you agreed that a correct abort decider oly NEEDS to
>>>>>>>>>>>>>>>> abort its simulation if the correct simulation by a pure
>>>>>>>>>>>>>>>> correct simulator of the input given to H (which doesn't
>>>>>>>>>>>>>>>> change, so for this case, still calls that original H)
>>>>>>>>>>>>>>>> will never reach a final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The question is does that machine described by the
>>>>>>>>>>>>>>>>>> input Halt when run, or, alternatively, does its
>>>>>>>>>>>>>>>>>> correct simulation (not just by H) run forever (and
>>>>>>>>>>>>>>>>>> thus needs to be aborted)?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Since you know that H(D,D) must abort its simulation to
>>>>>>>>>>>>>>>>> prevent its
>>>>>>>>>>>>>>>>> own infinite execution I don't understand why you would
>>>>>>>>>>>>>>>>> lie about it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But an H that doesn't abort and an H that does abort are
>>>>>>>>>>>>>>>> looking at different inputs "D", since you agree that
>>>>>>>>>>>>>>>> the behavior of D changes based on the H that it is using.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Not at all. Of the infinite set of every possible
>>>>>>>>>>>>>>> implementation of
>>>>>>>>>>>>>>> H where H(D,D) simulates its input everyone that chose to
>>>>>>>>>>>>>>> abort is
>>>>>>>>>>>>>>> necessarily correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I really want to get on to the next step and see if any
>>>>>>>>>>>>>>>>> input can
>>>>>>>>>>>>>>>>> fool an abort decider into making the wrong abort
>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But you need to get this step right first.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Perhaps you already know that you are not up to this
>>>>>>>>>>>>>>>>> challenge?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, it seems that YOU are not up to it, as you can't
>>>>>>>>>>>>>>>> seem to understand the error that you are making.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You keep on lying to yourself about what your
>>>>>>>>>>>>>>>> requirements are.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am not the one that keeps using the strawman deception
>>>>>>>>>>>>>>> to change
>>>>>>>>>>>>>>> the subject away from H(D,D) an abort decider for the
>>>>>>>>>>>>>>> above D.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Neither am I.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> YOU agreed that the criteria for an abort decider is only
>>>>>>>>>>>>>> CORRECT if a CORRECT simulation of the exact input given
>>>>>>>>>>>>>> to H(D,D) (i.e UTM(D,D) ) does not halt, where D still
>>>>>>>>>>>>>> calls that H(D,D)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I never agreed to that.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes you did:
>>>>>>>>>
>>>>>>>>> *You just admitted to lying abut this* (see below).
>>>>>>>>
>>>>>>>> Nope, see below.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>>>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>  >> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>  >>
>>>>>>>>>>>>  > Yes that is correct.
>>>>>>>>>>>>  >
>>>>>>>>>>>>
>>>>>>>>>>>> Since the ONLY definition of a "Correct Simulator" is a
>>>>>>>>>>>> simulator that never aborts, you did..
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because we have been over this hundreds of times you know
>>>>>>>>>>> that I mean
>>>>>>>>>>> that a correct simulator means that every step that H
>>>>>>>>>>> simulates was
>>>>>>>>>>> correctly simulated, so why are you lying about this now?
>>>>>>>>>>>
>>>>>>>>>>> Are you trying to run out the clock on my rebuttals?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And YOU know that when *I* say "Correct Simulation", I mean
>>>>>>>>>> per the definition of a UTM that exactly duplicates the full
>>>>>>>>>> behavior of the input machine, and you agreed to ME.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Then you are admitting that you lied when you claimed that
>>>>>>>>> I believed that.
>>>>>>>>
>>>>>>>> YOU agreed with what *I* said. When I speak, words mean what *I*
>>>>>>>> hold them to beleive.
>>>>>>>>
>>>>>>>
>>>>>>> Are you really willing to bet your soul on that?
>>>>>>
>>>>>> As I said, YES, but are you?
>>>>>>
>>>>> Seems foolish to me. I never bet what I cannot afford to lose.
>>>>> Maybe you should ask the leadership of your church about this.
>>>>
>>>> But I know I can't lose, because I know of the promise of God and
>>>> that he has written my name in his Book of Life.
>>>>
>>>>>
>>>>>> Or does the fact that you already lost it mean it doesn't matter
>>>>>> to you.
>>>>>>
>>>>> That is not what scripture says.
>>>>
>>>> It does, but you do not understand it.
>>>>
>>>> You seem to have reached the point where God has turned you over to
>>>> your own desires, giving you the taste of eternal hell here, to see
>>>> if you will repent.
>>>>
>>>> If you do, you can claim your soul back, but for now, YOU have given
>>>> it to the devil.
>>>>
>>
>> So, you now go and show that you will also LIE about the meaning of
>> verses in the Bible.
>>
>> You are going to show that just as you try to misinterprete the works
>> of the great logicitians that have proved things you don't like, you
>> are also going to misinterpete the Bible to try to juistify your own
>> ideas.
>>
>> You are just Proof-Texting and doing Eisogesis on the text, instead of
>> Exegesis to discover the actual meaning.
>>
>>>
>>> Galatians 5:14 NRSV
>>> For the whole law is summed up in a single commandment,
>>> “You shall love your neighbor as yourself.”
>>
>> Remember, Galatians was written to a CHURCH of BELIEVERS, who were
>> suffering some persecution. There was a movement to try to push them
>> back to "Old Testament Judiasm", which was a Key part of Paul's
>> discourse. Being Beleivers, talking about the need to love God, wasn't
>> an issue, but pointing out that the ceremonial law and animal
>> sacrifice system was no longer applicable, because it had been
>> fulfilled. The MORAL law, which is the part that derives from the
>> "Second Greatest Commandment"
>>
>>  From Matthew 22:37 Jesus replied: “ ‘Love the Lord your God with all
>> your heart and with all your soul and with all your mind.’ 38 This is
>> the first and greatest commandment. And the second is like it: ‘Love
>> your neighbor as yourself.’ All the Law and the Prophets hang on these
>> two commandments.”
>>
>> Paul can help interprete Jesus, but can not change his meaning.
>>
>>>
>>> Isaiah 45:6
>>> That they may know from the rising of the sun, and from
>>> the west, that there is none beside me. I am the Lord, and
>>> there is none else.
>>>
>>> When one takes the above two verses 100% literally as if
>>> they were a mathematical specification one gets an entirely
>>> different meaning than everyone else gets.
>>
>> But 100% literal is NOT how you need to take the verses of the Bible.
>>
>>>
>>> I checked the last very with two Hebrew bible scholars and
>>> they both agree that it says nothing besides God actually
>>> exists.
>>
>> So? Interpreting a verse out of context is just a pretext.
>>
>>>
>>> All those lead by the Holy Spirit are on the right path. I
>>> am doing what I can for additional spiritual confirmation.
>>
>> I seriously doubt you are being lead by the HOLY Spirit, as he can not
>> stand to be with a liar.
>>
>> OR someone who blasphemes God by claiming to be comparable.
>>
>> It is likely some other "spirit" guiding you to that lake of fire.
>>
>>
>>>
>>>>>
>>>>>>>
>>>>>>>> Thus, YOU AGREED to MY definition, since you agrees with NO
>>>>>>>> qualifications of your statement.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> YOU definition is just illogical as it means that the behavior
>>>>>>>>>> of a machine is determined by the behavior of a machine that
>>>>>>>>>> is not it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because deciders must always halt every H that never halts has
>>>>>>>>> incorrect
>>>>>>>>> halting behavior and every H that halts has correct halting
>>>>>>>>> behavior.
>>>>>>>>
>>>>>>>> That isn't what a "Halt Decider" means, and you are just proving
>>>>>>>> you are just STUPID.
>>>>>>>>
>>>>>>>
>>>>>>> So now you are disagreeing that ALL deciders must always halt?
>>>>>>
>>>>>> Nope, but Halting isn't enough to make a foo decider a foo decider.
>>>>>>
>>>>> Sure I can certainly agree with that.
>>>>
>>>> So, the fact that you deciders just Halt, doesn't make the correct
>>>> Halt Deciders, they are only that if their answer to H(M,d) matchs
>>>> Halts(M,d) for all M and d, or for this particular case H(D,D) must
>>>> match Halts(D,D), which is doesn't, so they are not correct halt
>>>> deciders.
>>>>
>>>
>>> // A is an abort decider
>>
>>
>>
>>> 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.
>>>
>>> When-so-ever a simulating abort decider correctly determines in N
>>> steps of correct simulation that the behavior of its input matches
>>> a correct predefined non-halting behavior pattern the abort decider
>>> is always correct to abort the simulation of this input.
>>
>> So, does A have a SPECIFIC set of code that it is running?
>>
>> If not, your whole arguement is just a LIE.
>>
>> If it does, how can it determine what it would do if it doesn't do
>> what it does, that would be something else, not it.
>>
>> And, since you are defining "B" to use what ever A happens to exist at
>> the moment. B isn't a computation or even a program by the normal
>> definition of one.
>>
>> In this case, I would say you are correct to say that THIS problem is
>> "invalid", due to the automagically changing input as you change the
>> decider looking at it.
>>
>> Of course, since the REAL Haltng problem doesn't do that, it is still
>> valid.
>>
>>>
>>>>>
>>>>>> You are just playing with words again.
>>>>>>
>>>>>> To be a Halt Decider, the output needs to match the Halting Function.
>>>>>>
>>>>> I will agree that is the common understanding.
>>>>> The is no preexisting common understanding of a simulating abort
>>>>> decider because (to the best of my knowledge) no one every thought
>>>>> of this before.
>>>>
>>>> And either it is equivalent, or it isn't. If it isn't, then it says
>>>> nothing about the Halting Problem.
>>>>
>>>
>>> It is too disingenuous to say that it say nothing about the halting
>>> problem. It as much as solves a different version of the halting
>>> problem.
>>
>> Which isn't the Halting Problem. Something that isn't the Halting
>> Problem doesn't say much about the actual Halting Problem.
>>
>> Now, if you want to try to actually formally define your differences,
>> and some how show that they are actually minor and insignificant, you
>> might be able to do something, but when you throw out fundamental
>> principles. liek a program is what the program is, you are just lying
>> about what you are doing.
>>
>>>
>>> If the original version is incoherent the same sort of way that Naive
>>> set theory allowed Russell's Paradox then an abort decider corrects
>>> the erroneous halting problem that same way that ZFC corrected Naive
>>> set theory.
>>>
>>>> Since the only rational definition of "Needs to Abort its
>>>> simulation", is that a correct simulation of the input would not
>>>> halt, then your "abort deciders" turn out to need to be actually
>>>> Halt Decider.
>>>>
>>>
>>> An abort decider <is> a halt decider from its own point of view.
>>> It is not and cannot be a halt decider from any other POV.
>>
>> Only by lying to itself.
>>
>> Since Halt Deciding is a OBJECTIVE criteria, it can't be equivalent,
>> or even very similar to your SUBJECTIVE new criteria, which you can't
>> even properly define, since you keep on with your using of
>> non-algorithmic terms to describe what it is to do.
>>
>>>
>>>> The logic of looking at what would happen if H was a different
>>>> machine ib a way that actually changed the behavior of the input
>>>> (because you either make the input not a computation, or re-write
>>>> the input) is ust invalid.
>>>>
>>>
>>> The whole class of every H(D,D) that simulates its input
>>> is divided into two sub-classes:
>>> (a) H(D,D) that DOES NOT abort its simulation is incorrect
>>>      (ABOUT THIS ABORT DECISION)
>>>      because it would never halt and all deciders must always halt.
>>>
>>> (b) H(D,D) that DOES abort its simulation is correct
>>>      (ABOUT THIS ABORT DECISION)
>>>      because it would halt and all deciders must always halt.
>>
>> So, it is a DECIDER, but you haven't proven it is a CORRECT decider
>> about any defined mapping (other than the trivial problem of it maps
>> what it generates).
>>
>
> I haven't bothered to repeat this again because you far too consistently
> deny easily verified facts. By whatever process that you can tell that
> every member of (a) is incorrect and every member of (b) is correct is
> the same one that H uses.

On 3/27/2024 9:34 PM, Richard Damon wrote:
> On 3/27/24 10:07 PM, olcott wrote:
>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>> On 3/26/24 11:10 PM, olcott wrote:
>>>> On 3/26/2024 9:18 PM, Richard Damon wrote:
>>>>> On 3/26/24 11:33 AM, olcott wrote:
>>>>>> On 3/26/2024 6:43 AM, Richard Damon wrote:
>>>>>>> On 3/25/24 11:29 PM, olcott wrote:
>>>>>>>> On 3/25/2024 10:01 PM, Richard Damon wrote:
>>>>>>>>> On 3/25/24 10:53 PM, olcott wrote:
>>>>>>>>>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/25/24 9:35 PM, olcott wrote:
>>>>>>>>>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot be
>>>>>>>>>>>>>>>>>>>>>>>>>> fooled by any pathological input?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int
>>>>>>>>>>>>>>>>>>>>>>>>>> function
>>>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Of all of the elements of the set of H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>> where H simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>> input there are matched pairs of otherwise
>>>>>>>>>>>>>>>>>>>>>>>>>> identical elements that
>>>>>>>>>>>>>>>>>>>>>>>>>> only differ by whether they abort their
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or not.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The half of these that don't abort are
>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect because all deciders
>>>>>>>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct
>>>>>>>>>>>>>>>>>>>>>>>>>> about the abort/no abort
>>>>>>>>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No. The other, aborting, half is just wrong,
>>>>>>>>>>>>>>>>>>>>>>>>> because it aborts when it is not needed. So,
>>>>>>>>>>>>>>>>>>>>>>>>> the half that aborts is wrong and it may be
>>>>>>>>>>>>>>>>>>>>>>>>> argued that it is better to not abort something
>>>>>>>>>>>>>>>>>>>>>>>>> that halts on its own and that
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> At least two software engineers with masters
>>>>>>>>>>>>>>>>>>>>>>>> degrees in computer science
>>>>>>>>>>>>>>>>>>>>>>>> disagree.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Two is not many, considering that with Google for
>>>>>>>>>>>>>>>>>>>>>>> any invalid idea it is easy to find a several
>>>>>>>>>>>>>>>>>>>>>>> people with a master degree supporting it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Exactly what are you software engineering skills?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I have been professionally programming since 1986
>>>>>>>>>>>>>>>>>>>>>>> in several languages. (Non professionally I
>>>>>>>>>>>>>>>>>>>>>>> started programming in 1975). Since about 1990 I
>>>>>>>>>>>>>>>>>>>>>>> programmed in C and since about 2000 in C++.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I have been a professional C++ software engineer
>>>>>>>>>>>>>>>>>>>>>>>> since Y2K.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I'm sorry to hear that olcott has been so smart,
>>>>>>>>>>>>>>>>>>>>>>> but now he does not even sees what even a
>>>>>>>>>>>>>>>>>>>>>>> beginner sees.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D)
>>>>>>>>>>>>>>>>>>>>>> that simulates D(D)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Even a beginner sees that, if the H that aborts is
>>>>>>>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false
>>>>>>>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless
>>>>>>>>>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>>>>>>> The D simulated by any implementation of H (that
>>>>>>>>>>>>>>>>>>>> aborts or does not
>>>>>>>>>>>>>>>>>>>> abort its simulation) shown above cannot possibly
>>>>>>>>>>>>>>>>>>>> reach its own line 04
>>>>>>>>>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But you agreed that a correct abort decider oly NEEDS
>>>>>>>>>>>>>>>>> to abort its simulation if the correct simulation by a
>>>>>>>>>>>>>>>>> pure correct simulator of the input given to H (which
>>>>>>>>>>>>>>>>> doesn't change, so for this case, still calls that
>>>>>>>>>>>>>>>>> original H) will never reach a final state.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The question is does that machine described by the
>>>>>>>>>>>>>>>>>>> input Halt when run, or, alternatively, does its
>>>>>>>>>>>>>>>>>>> correct simulation (not just by H) run forever (and
>>>>>>>>>>>>>>>>>>> thus needs to be aborted)?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Since you know that H(D,D) must abort its simulation
>>>>>>>>>>>>>>>>>> to prevent its
>>>>>>>>>>>>>>>>>> own infinite execution I don't understand why you
>>>>>>>>>>>>>>>>>> would lie about it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But an H that doesn't abort and an H that does abort
>>>>>>>>>>>>>>>>> are looking at different inputs "D", since you agree
>>>>>>>>>>>>>>>>> that the behavior of D changes based on the H that it
>>>>>>>>>>>>>>>>> is using.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not at all. Of the infinite set of every possible
>>>>>>>>>>>>>>>> implementation of
>>>>>>>>>>>>>>>> H where H(D,D) simulates its input everyone that chose
>>>>>>>>>>>>>>>> to abort is
>>>>>>>>>>>>>>>> necessarily correct.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I really want to get on to the next step and see if
>>>>>>>>>>>>>>>>>> any input can
>>>>>>>>>>>>>>>>>> fool an abort decider into making the wrong abort
>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But you need to get this step right first.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Perhaps you already know that you are not up to this
>>>>>>>>>>>>>>>>>> challenge?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, it seems that YOU are not up to it, as you can't
>>>>>>>>>>>>>>>>> seem to understand the error that you are making.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You keep on lying to yourself about what your
>>>>>>>>>>>>>>>>> requirements are.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am not the one that keeps using the strawman deception
>>>>>>>>>>>>>>>> to change
>>>>>>>>>>>>>>>> the subject away from H(D,D) an abort decider for the
>>>>>>>>>>>>>>>> above D.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Neither am I.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> YOU agreed that the criteria for an abort decider is only
>>>>>>>>>>>>>>> CORRECT if a CORRECT simulation of the exact input given
>>>>>>>>>>>>>>> to H(D,D) (i.e UTM(D,D) ) does not halt, where D still
>>>>>>>>>>>>>>> calls that H(D,D)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I never agreed to that.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes you did:
>>>>>>>>>>
>>>>>>>>>> *You just admitted to lying abut this* (see below).
>>>>>>>>>
>>>>>>>>> Nope, see below.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>>>>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>  >> To me, for H to NEED to abort its simulation, that
>>>>>>>>>>>>> means that when giving the input to a correct simulator,
>>>>>>>>>>>>> that simulator will not halt.
>>>>>>>>>>>>>  >>
>>>>>>>>>>>>>  > Yes that is correct.
>>>>>>>>>>>>>  >
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since the ONLY definition of a "Correct Simulator" is a
>>>>>>>>>>>>> simulator that never aborts, you did..
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Because we have been over this hundreds of times you know
>>>>>>>>>>>> that I mean
>>>>>>>>>>>> that a correct simulator means that every step that H
>>>>>>>>>>>> simulates was
>>>>>>>>>>>> correctly simulated, so why are you lying about this now?
>>>>>>>>>>>>
>>>>>>>>>>>> Are you trying to run out the clock on my rebuttals?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And YOU know that when *I* say "Correct Simulation", I mean
>>>>>>>>>>> per the definition of a UTM that exactly duplicates the full
>>>>>>>>>>> behavior of the input machine, and you agreed to ME.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then you are admitting that you lied when you claimed that
>>>>>>>>>> I believed that.
>>>>>>>>>
>>>>>>>>> YOU agreed with what *I* said. When I speak, words mean what
>>>>>>>>> *I* hold them to beleive.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Are you really willing to bet your soul on that?
>>>>>>>
>>>>>>> As I said, YES, but are you?
>>>>>>>
>>>>>> Seems foolish to me. I never bet what I cannot afford to lose.
>>>>>> Maybe you should ask the leadership of your church about this.
>>>>>
>>>>> But I know I can't lose, because I know of the promise of God and
>>>>> that he has written my name in his Book of Life.
>>>>>
>>>>>>
>>>>>>> Or does the fact that you already lost it mean it doesn't matter
>>>>>>> to you.
>>>>>>>
>>>>>> That is not what scripture says.
>>>>>
>>>>> It does, but you do not understand it.
>>>>>
>>>>> You seem to have reached the point where God has turned you over to
>>>>> your own desires, giving you the taste of eternal hell here, to see
>>>>> if you will repent.
>>>>>
>>>>> If you do, you can claim your soul back, but for now, YOU have
>>>>> given it to the devil.
>>>>>
>>>
>>> So, you now go and show that you will also LIE about the meaning of
>>> verses in the Bible.
>>>
>>> You are going to show that just as you try to misinterprete the works
>>> of the great logicitians that have proved things you don't like, you
>>> are also going to misinterpete the Bible to try to juistify your own
>>> ideas.
>>>
>>> You are just Proof-Texting and doing Eisogesis on the text, instead
>>> of Exegesis to discover the actual meaning.
>>>
>>>>
>>>> Galatians 5:14 NRSV
>>>> For the whole law is summed up in a single commandment,
>>>> “You shall love your neighbor as yourself.”
>>>
>>> Remember, Galatians was written to a CHURCH of BELIEVERS, who were
>>> suffering some persecution. There was a movement to try to push them
>>> back to "Old Testament Judiasm", which was a Key part of Paul's
>>> discourse. Being Beleivers, talking about the need to love God,
>>> wasn't an issue, but pointing out that the ceremonial law and animal
>>> sacrifice system was no longer applicable, because it had been
>>> fulfilled. The MORAL law, which is the part that derives from the
>>> "Second Greatest Commandment"
>>>
>>>  From Matthew 22:37 Jesus replied: “ ‘Love the Lord your God with all
>>> your heart and with all your soul and with all your mind.’ 38 This is
>>> the first and greatest commandment. And the second is like it: ‘Love
>>> your neighbor as yourself.’ All the Law and the Prophets hang on
>>> these two commandments.”
>>>
>>> Paul can help interprete Jesus, but can not change his meaning.
>>>
>>>>
>>>> Isaiah 45:6
>>>> That they may know from the rising of the sun, and from
>>>> the west, that there is none beside me. I am the Lord, and
>>>> there is none else.
>>>>
>>>> When one takes the above two verses 100% literally as if
>>>> they were a mathematical specification one gets an entirely
>>>> different meaning than everyone else gets.
>>>
>>> But 100% literal is NOT how you need to take the verses of the Bible.
>>>
>>>>
>>>> I checked the last very with two Hebrew bible scholars and
>>>> they both agree that it says nothing besides God actually
>>>> exists.
>>>
>>> So? Interpreting a verse out of context is just a pretext.
>>>
>>>>
>>>> All those lead by the Holy Spirit are on the right path. I
>>>> am doing what I can for additional spiritual confirmation.
>>>
>>> I seriously doubt you are being lead by the HOLY Spirit, as he can
>>> not stand to be with a liar.
>>>
>>> OR someone who blasphemes God by claiming to be comparable.
>>>
>>> It is likely some other "spirit" guiding you to that lake of fire.
>>>
>>>
>>>>
>>>>>>
>>>>>>>>
>>>>>>>>> Thus, YOU AGREED to MY definition, since you agrees with NO
>>>>>>>>> qualifications of your statement.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> YOU definition is just illogical as it means that the
>>>>>>>>>>> behavior of a machine is determined by the behavior of a
>>>>>>>>>>> machine that is not it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because deciders must always halt every H that never halts has
>>>>>>>>>> incorrect
>>>>>>>>>> halting behavior and every H that halts has correct halting
>>>>>>>>>> behavior.
>>>>>>>>>
>>>>>>>>> That isn't what a "Halt Decider" means, and you are just
>>>>>>>>> proving you are just STUPID.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So now you are disagreeing that ALL deciders must always halt?
>>>>>>>
>>>>>>> Nope, but Halting isn't enough to make a foo decider a foo decider.
>>>>>>>
>>>>>> Sure I can certainly agree with that.
>>>>>
>>>>> So, the fact that you deciders just Halt, doesn't make the correct
>>>>> Halt Deciders, they are only that if their answer to H(M,d) matchs
>>>>> Halts(M,d) for all M and d, or for this particular case H(D,D) must
>>>>> match Halts(D,D), which is doesn't, so they are not correct halt
>>>>> deciders.
>>>>>
>>>>
>>>> // A is an abort decider
>>>
>>>
>>>
>>>> 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.
>>>>
>>>> When-so-ever a simulating abort decider correctly determines in N
>>>> steps of correct simulation that the behavior of its input matches
>>>> a correct predefined non-halting behavior pattern the abort decider
>>>> is always correct to abort the simulation of this input.
>>>
>>> So, does A have a SPECIFIC set of code that it is running?
>>>
>>> If not, your whole arguement is just a LIE.
>>>
>>> If it does, how can it determine what it would do if it doesn't do
>>> what it does, that would be something else, not it.
>>>
>>> And, since you are defining "B" to use what ever A happens to exist
>>> at the moment. B isn't a computation or even a program by the normal
>>> definition of one.
>>>
>>> In this case, I would say you are correct to say that THIS problem is
>>> "invalid", due to the automagically changing input as you change the
>>> decider looking at it.
>>>
>>> Of course, since the REAL Haltng problem doesn't do that, it is still
>>> valid.
>>>
>>>>
>>>>>>
>>>>>>> You are just playing with words again.
>>>>>>>
>>>>>>> To be a Halt Decider, the output needs to match the Halting
>>>>>>> Function.
>>>>>>>
>>>>>> I will agree that is the common understanding.
>>>>>> The is no preexisting common understanding of a simulating abort
>>>>>> decider because (to the best of my knowledge) no one every thought
>>>>>> of this before.
>>>>>
>>>>> And either it is equivalent, or it isn't. If it isn't, then it says
>>>>> nothing about the Halting Problem.
>>>>>
>>>>
>>>> It is too disingenuous to say that it say nothing about the halting
>>>> problem. It as much as solves a different version of the halting
>>>> problem.
>>>
>>> Which isn't the Halting Problem. Something that isn't the Halting
>>> Problem doesn't say much about the actual Halting Problem.
>>>
>>> Now, if you want to try to actually formally define your differences,
>>> and some how show that they are actually minor and insignificant, you
>>> might be able to do something, but when you throw out fundamental
>>> principles. liek a program is what the program is, you are just lying
>>> about what you are doing.
>>>
>>>>
>>>> If the original version is incoherent the same sort of way that Naive
>>>> set theory allowed Russell's Paradox then an abort decider corrects
>>>> the erroneous halting problem that same way that ZFC corrected Naive
>>>> set theory.
>>>>
>>>>> Since the only rational definition of "Needs to Abort its
>>>>> simulation", is that a correct simulation of the input would not
>>>>> halt, then your "abort deciders" turn out to need to be actually
>>>>> Halt Decider.
>>>>>
>>>>
>>>> An abort decider <is> a halt decider from its own point of view.
>>>> It is not and cannot be a halt decider from any other POV.
>>>
>>> Only by lying to itself.
>>>
>>> Since Halt Deciding is a OBJECTIVE criteria, it can't be equivalent,
>>> or even very similar to your SUBJECTIVE new criteria, which you can't
>>> even properly define, since you keep on with your using of
>>> non-algorithmic terms to describe what it is to do.
>>>
>>>>
>>>>> The logic of looking at what would happen if H was a different
>>>>> machine ib a way that actually changed the behavior of the input
>>>>> (because you either make the input not a computation, or re-write
>>>>> the input) is ust invalid.
>>>>>
>>>>
>>>> The whole class of every H(D,D) that simulates its input
>>>> is divided into two sub-classes:
>>>> (a) H(D,D) that DOES NOT abort its simulation is incorrect
>>>>      (ABOUT THIS ABORT DECISION)
>>>>      because it would never halt and all deciders must always halt.
>>>>
>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>      (ABOUT THIS ABORT DECISION)
>>>>      because it would halt and all deciders must always halt.
>>>
>>> So, it is a DECIDER, but you haven't proven it is a CORRECT decider
>>> about any defined mapping (other than the trivial problem of it maps
>>> what it generates).
>>>
>>
>> I haven't bothered to repeat this again because you far too consistently
>> deny easily verified facts. By whatever process that you can tell that
>> every member of (a) is incorrect and every member of (b) is correct is
>> the same one that H uses.
>
> Nope. JUST MORE LIES showing your utter stupidity.
>
>>
>> It took you far too long to acknowledge what you did and I am concerned
>> for your soul. Getting caught up in childish head games may be quite fun
>> yet not at the expense of your soul.
>
> I am concerned for YOUR soul, but fear you may be too far gone, since
> you have clearly fallen for the devils lies.
>
>>
>>> Your logic ignores that D changes its behavior based on the H that it
>>> uses,
>>
>> *I have known this for two years and you have denied this for two years*
>
> But if D changes its behavior based on the H it calls, then looking at
> it with ANY H other than the one that is the one that you claim to give
> the right answer is just a LIE.
>
> And That H does what it DOES, and doesn't "Correctly Simulate" the input
> to the point that shows that the input is non-halting, and every logic
> you have shown is based on LYING that the H that you are working with,
> which is actually a different H than you final H, is somehow "the same"
> even though it uses a different one.
>
> So, your arguement is just filled with LIES.
>
>>
>>> so the fact that a D in group a, and thus using a group a H is not
>>> halting says nothing about a a in group b,
>>
>> Every element of (a) is incorrect thus making every element of (b)
>> correct about the abort decision.
>
>
> NOPE. JUST MORE LIES.
>
> Proving you are totally STUPID.
>
>>
>>> and thus using a group b H. It can be shown that all these D are
>>> HALTING, and thus there decider does NOT need to abort its
>>> simulation, even though it DOES.
>>>
>>>>
>>>> Fred is seeming to understand this now.
>>>> On 3/26/2024 6:23 AM, Fred. Zwarts wrote:
>>>>  > 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.
>>>>
>>>>>>
>>>>>> When-so-ever a simulating abort decider correctly determines in N
>>>>>> steps of correct simulation that the behavior of its input matches
>>>>>> a correct predefined non-halting behavior pattern the abort decider
>>>>>> is always correct to abort the simulation of this input.
>>>>>
>>>>> Except there is no "correct predefined non-halting behavior
>>>>> pattern" that exists in the simulation of this D(D), since that
>>>>> input WILL HALT if the H that it is built on tries to take ANY of
>>>>> the patterns that are reached in the simulation, to abort and
>>>>> return 0.
>>>>>
>>>>> This was proven a couple of YEARS ago, and you ignored it, because
>>>>> it was just an inconvienent truth.
>>>>>
>>>>> Your logic is based on ASSUME SOMETHING TO EXIST, even if you can
>>>>> not prove that it does. That is just UNSOUND logic, showing that
>>>>> you have an UNSOUND logic system.
>>>>>
>>>>>>
>>>>>>> To be an Abort Decider, the output needs to match the correct
>>>>>>> definition of an Abort Decider, namely would the correct
>>>>>>> simulation of the input halt in a finite number of steps, or does
>>>>>>> the correct simulation need to be aborted to come to an end,
>>>>>>>
>>>>>> Something like that. Would simulated D stop running on its own
>>>>>> without ever having its simulation aborted?
>>>>>
>>>>> Right, but the D MUST be based on the ACTUAL H that you claim gives
>>>>> the right answer. If that does abort, then you MUST give the input
>>>>> to a DIFFERENT simulator, while keeping its pairing to that H.
>>>>>
>>>>>>
>>>>>> Because you continue to lie about H(D,D) needing to abort its
>>>>>> simulation
>>>>>> we are not getting to the point where we can see if any input
>>>>>> could fool
>>>>>> an abort decider into getting the wrong abort decision answer.
>>>>>>
>>>>>
>>>>> But I have shown that the H(D,D) that aborts and returns 0, does
>>>>> not need to actually abort its simulation.
>>>>
>>>> *I really can't see how that is not simply a lie*
>>>> *I really can't see how that is not simply a lie*
>>>> *I really can't see how that is not simply a lie*
>>>>
>>>>
>>>
>>> Yes, you can't, because you lie to yourself about the meaning of the
>>> words.
>>>
>>
>> I simply take key verses 100% literally as if God would always
>> say 100% exactly what he means and always means exactly 100% of
>> what he says. I am not aware of anyone else that does this.
>
> Which is the DEVIL'S way to read the Bible.
>
> Look at his example of Tempting Jesus in the desert. Quoting scriptures
> out of context, and trying to offer a LITERAL meaning that differed from
> the actual meaning, that Jesus pointed out by his reply.
>
>>
>> If one does not do this then the bible can be taken in too many
>> different ways.
>
> Nope.
>
> YOUR way allows all the variation,
>
>>
>> All of the different denominations having their differing views
>> proves that (at least) to the extent that they differ they are
>> incorrect.
>
> And the key is to actually STUDY to see what is the REAL truth behind
> all the variations, and what differences are important, and what are
> actually insubstantial.
>
> When you actually KNOW what the Bible says, and talk to others who also
> KNOW what the Bible says, you can discuss things with people even from
> very dofferent backgrounds, and find agreement.
>
> You get the big disagreements from people who don't actually know the
> Bible, but just the "Dogma" of their religious community. These are not
> really beleivers or possibly not even really "Christians" that Christ
> will take in the last day.
>

On 3/27/24 11:58 PM, olcott wrote:
> On 3/27/2024 9:34 PM, Richard Damon wrote:
>> On 3/27/24 10:07 PM, olcott wrote:
>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>> On 3/26/24 11:10 PM, olcott wrote:
>>>>> On 3/26/2024 9:18 PM, Richard Damon wrote:
>>>>>> On 3/26/24 11:33 AM, olcott wrote:
>>>>>>> On 3/26/2024 6:43 AM, Richard Damon wrote:
>>>>>>>> On 3/25/24 11:29 PM, olcott wrote:
>>>>>>>>> On 3/25/2024 10:01 PM, Richard Damon wrote:
>>>>>>>>>> On 3/25/24 10:53 PM, olcott wrote:
>>>>>>>>>>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/25/24 9:35 PM, olcott wrote:
>>>>>>>>>>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>> be fooled by any pathological input?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int
>>>>>>>>>>>>>>>>>>>>>>>>>>> function
>>>>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Of all of the elements of the set of H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> where H simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>> input there are matched pairs of otherwise
>>>>>>>>>>>>>>>>>>>>>>>>>>> identical elements that
>>>>>>>>>>>>>>>>>>>>>>>>>>> only differ by whether they abort their
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or not.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The half of these that don't abort are
>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect because all deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct
>>>>>>>>>>>>>>>>>>>>>>>>>>> about the abort/no abort
>>>>>>>>>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No. The other, aborting, half is just wrong,
>>>>>>>>>>>>>>>>>>>>>>>>>> because it aborts when it is not needed. So,
>>>>>>>>>>>>>>>>>>>>>>>>>> the half that aborts is wrong and it may be
>>>>>>>>>>>>>>>>>>>>>>>>>> argued that it is better to not abort
>>>>>>>>>>>>>>>>>>>>>>>>>> something that halts on its own and that
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> At least two software engineers with masters
>>>>>>>>>>>>>>>>>>>>>>>>> degrees in computer science
>>>>>>>>>>>>>>>>>>>>>>>>> disagree.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Two is not many, considering that with Google
>>>>>>>>>>>>>>>>>>>>>>>> for any invalid idea it is easy to find a
>>>>>>>>>>>>>>>>>>>>>>>> several people with a master degree supporting it.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Exactly what are you software engineering skills?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I have been professionally programming since
>>>>>>>>>>>>>>>>>>>>>>>> 1986 in several languages. (Non professionally I
>>>>>>>>>>>>>>>>>>>>>>>> started programming in 1975). Since about 1990 I
>>>>>>>>>>>>>>>>>>>>>>>> programmed in C and since about 2000 in C++.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I have been a professional C++ software
>>>>>>>>>>>>>>>>>>>>>>>>> engineer since Y2K.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I'm sorry to hear that olcott has been so smart,
>>>>>>>>>>>>>>>>>>>>>>>> but now he does not even sees what even a
>>>>>>>>>>>>>>>>>>>>>>>> beginner sees.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D)
>>>>>>>>>>>>>>>>>>>>>>> that simulates D(D)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Even a beginner sees that, if the H that aborts is
>>>>>>>>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false
>>>>>>>>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless
>>>>>>>>>>>>>>>>>>>>>> aborted).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I am estimating that you must be fibbing about your
>>>>>>>>>>>>>>>>>>>>> programming skill.
>>>>>>>>>>>>>>>>>>>>> The D simulated by any implementation of H (that
>>>>>>>>>>>>>>>>>>>>> aborts or does not
>>>>>>>>>>>>>>>>>>>>> abort its simulation) shown above cannot possibly
>>>>>>>>>>>>>>>>>>>>> reach its own line 04
>>>>>>>>>>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But you agreed that a correct abort decider oly NEEDS
>>>>>>>>>>>>>>>>>> to abort its simulation if the correct simulation by a
>>>>>>>>>>>>>>>>>> pure correct simulator of the input given to H (which
>>>>>>>>>>>>>>>>>> doesn't change, so for this case, still calls that
>>>>>>>>>>>>>>>>>> original H) will never reach a final state.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The question is does that machine described by the
>>>>>>>>>>>>>>>>>>>> input Halt when run, or, alternatively, does its
>>>>>>>>>>>>>>>>>>>> correct simulation (not just by H) run forever (and
>>>>>>>>>>>>>>>>>>>> thus needs to be aborted)?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Since you know that H(D,D) must abort its simulation
>>>>>>>>>>>>>>>>>>> to prevent its
>>>>>>>>>>>>>>>>>>> own infinite execution I don't understand why you
>>>>>>>>>>>>>>>>>>> would lie about it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But an H that doesn't abort and an H that does abort
>>>>>>>>>>>>>>>>>> are looking at different inputs "D", since you agree
>>>>>>>>>>>>>>>>>> that the behavior of D changes based on the H that it
>>>>>>>>>>>>>>>>>> is using.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Not at all. Of the infinite set of every possible
>>>>>>>>>>>>>>>>> implementation of
>>>>>>>>>>>>>>>>> H where H(D,D) simulates its input everyone that chose
>>>>>>>>>>>>>>>>> to abort is
>>>>>>>>>>>>>>>>> necessarily correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I really want to get on to the next step and see if
>>>>>>>>>>>>>>>>>>> any input can
>>>>>>>>>>>>>>>>>>> fool an abort decider into making the wrong abort
>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But you need to get this step right first.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Perhaps you already know that you are not up to this
>>>>>>>>>>>>>>>>>>> challenge?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, it seems that YOU are not up to it, as you can't
>>>>>>>>>>>>>>>>>> seem to understand the error that you are making.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You keep on lying to yourself about what your
>>>>>>>>>>>>>>>>>> requirements are.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I am not the one that keeps using the strawman
>>>>>>>>>>>>>>>>> deception to change
>>>>>>>>>>>>>>>>> the subject away from H(D,D) an abort decider for the
>>>>>>>>>>>>>>>>> above D.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Neither am I.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> YOU agreed that the criteria for an abort decider is
>>>>>>>>>>>>>>>> only CORRECT if a CORRECT simulation of the exact input
>>>>>>>>>>>>>>>> given to H(D,D) (i.e UTM(D,D) ) does not halt, where D
>>>>>>>>>>>>>>>> still calls that H(D,D)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I never agreed to that.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes you did:
>>>>>>>>>>>
>>>>>>>>>>> *You just admitted to lying abut this* (see below).
>>>>>>>>>>
>>>>>>>>>> Nope, see below.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>>>>>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>  >> To me, for H to NEED to abort its simulation, that
>>>>>>>>>>>>>> means that when giving the input to a correct simulator,
>>>>>>>>>>>>>> that simulator will not halt.
>>>>>>>>>>>>>>  >>
>>>>>>>>>>>>>>  > Yes that is correct.
>>>>>>>>>>>>>>  >
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since the ONLY definition of a "Correct Simulator" is a
>>>>>>>>>>>>>> simulator that never aborts, you did..
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because we have been over this hundreds of times you know
>>>>>>>>>>>>> that I mean
>>>>>>>>>>>>> that a correct simulator means that every step that H
>>>>>>>>>>>>> simulates was
>>>>>>>>>>>>> correctly simulated, so why are you lying about this now?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Are you trying to run out the clock on my rebuttals?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And YOU know that when *I* say "Correct Simulation", I mean
>>>>>>>>>>>> per the definition of a UTM that exactly duplicates the full
>>>>>>>>>>>> behavior of the input machine, and you agreed to ME.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Then you are admitting that you lied when you claimed that
>>>>>>>>>>> I believed that.
>>>>>>>>>>
>>>>>>>>>> YOU agreed with what *I* said. When I speak, words mean what
>>>>>>>>>> *I* hold them to beleive.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Are you really willing to bet your soul on that?
>>>>>>>>
>>>>>>>> As I said, YES, but are you?
>>>>>>>>
>>>>>>> Seems foolish to me. I never bet what I cannot afford to lose.
>>>>>>> Maybe you should ask the leadership of your church about this.
>>>>>>
>>>>>> But I know I can't lose, because I know of the promise of God and
>>>>>> that he has written my name in his Book of Life.
>>>>>>
>>>>>>>
>>>>>>>> Or does the fact that you already lost it mean it doesn't matter
>>>>>>>> to you.
>>>>>>>>
>>>>>>> That is not what scripture says.
>>>>>>
>>>>>> It does, but you do not understand it.
>>>>>>
>>>>>> You seem to have reached the point where God has turned you over
>>>>>> to your own desires, giving you the taste of eternal hell here, to
>>>>>> see if you will repent.
>>>>>>
>>>>>> If you do, you can claim your soul back, but for now, YOU have
>>>>>> given it to the devil.
>>>>>>
>>>>
>>>> So, you now go and show that you will also LIE about the meaning of
>>>> verses in the Bible.
>>>>
>>>> You are going to show that just as you try to misinterprete the
>>>> works of the great logicitians that have proved things you don't
>>>> like, you are also going to misinterpete the Bible to try to
>>>> juistify your own ideas.
>>>>
>>>> You are just Proof-Texting and doing Eisogesis on the text, instead
>>>> of Exegesis to discover the actual meaning.
>>>>
>>>>>
>>>>> Galatians 5:14 NRSV
>>>>> For the whole law is summed up in a single commandment,
>>>>> “You shall love your neighbor as yourself.”
>>>>
>>>> Remember, Galatians was written to a CHURCH of BELIEVERS, who were
>>>> suffering some persecution. There was a movement to try to push them
>>>> back to "Old Testament Judiasm", which was a Key part of Paul's
>>>> discourse. Being Beleivers, talking about the need to love God,
>>>> wasn't an issue, but pointing out that the ceremonial law and animal
>>>> sacrifice system was no longer applicable, because it had been
>>>> fulfilled. The MORAL law, which is the part that derives from the
>>>> "Second Greatest Commandment"
>>>>
>>>>  From Matthew 22:37 Jesus replied: “ ‘Love the Lord your God with
>>>> all your heart and with all your soul and with all your mind.’ 38
>>>> This is the first and greatest commandment. And the second is like
>>>> it: ‘Love your neighbor as yourself.’ All the Law and the Prophets
>>>> hang on these two commandments.”
>>>>
>>>> Paul can help interprete Jesus, but can not change his meaning.
>>>>
>>>>>
>>>>> Isaiah 45:6
>>>>> That they may know from the rising of the sun, and from
>>>>> the west, that there is none beside me. I am the Lord, and
>>>>> there is none else.
>>>>>
>>>>> When one takes the above two verses 100% literally as if
>>>>> they were a mathematical specification one gets an entirely
>>>>> different meaning than everyone else gets.
>>>>
>>>> But 100% literal is NOT how you need to take the verses of the Bible.
>>>>
>>>>>
>>>>> I checked the last very with two Hebrew bible scholars and
>>>>> they both agree that it says nothing besides God actually
>>>>> exists.
>>>>
>>>> So? Interpreting a verse out of context is just a pretext.
>>>>
>>>>>
>>>>> All those lead by the Holy Spirit are on the right path. I
>>>>> am doing what I can for additional spiritual confirmation.
>>>>
>>>> I seriously doubt you are being lead by the HOLY Spirit, as he can
>>>> not stand to be with a liar.
>>>>
>>>> OR someone who blasphemes God by claiming to be comparable.
>>>>
>>>> It is likely some other "spirit" guiding you to that lake of fire.
>>>>
>>>>
>>>>>
>>>>>>>
>>>>>>>>>
>>>>>>>>>> Thus, YOU AGREED to MY definition, since you agrees with NO
>>>>>>>>>> qualifications of your statement.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> YOU definition is just illogical as it means that the
>>>>>>>>>>>> behavior of a machine is determined by the behavior of a
>>>>>>>>>>>> machine that is not it.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because deciders must always halt every H that never halts
>>>>>>>>>>> has incorrect
>>>>>>>>>>> halting behavior and every H that halts has correct halting
>>>>>>>>>>> behavior.
>>>>>>>>>>
>>>>>>>>>> That isn't what a "Halt Decider" means, and you are just
>>>>>>>>>> proving you are just STUPID.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So now you are disagreeing that ALL deciders must always halt?
>>>>>>>>
>>>>>>>> Nope, but Halting isn't enough to make a foo decider a foo decider.
>>>>>>>>
>>>>>>> Sure I can certainly agree with that.
>>>>>>
>>>>>> So, the fact that you deciders just Halt, doesn't make the correct
>>>>>> Halt Deciders, they are only that if their answer to H(M,d) matchs
>>>>>> Halts(M,d) for all M and d, or for this particular case H(D,D)
>>>>>> must match Halts(D,D), which is doesn't, so they are not correct
>>>>>> halt deciders.
>>>>>>
>>>>>
>>>>> // A is an abort decider
>>>>
>>>>
>>>>
>>>>> 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.
>>>>>
>>>>> When-so-ever a simulating abort decider correctly determines in N
>>>>> steps of correct simulation that the behavior of its input matches
>>>>> a correct predefined non-halting behavior pattern the abort decider
>>>>> is always correct to abort the simulation of this input.
>>>>
>>>> So, does A have a SPECIFIC set of code that it is running?
>>>>
>>>> If not, your whole arguement is just a LIE.
>>>>
>>>> If it does, how can it determine what it would do if it doesn't do
>>>> what it does, that would be something else, not it.
>>>>
>>>> And, since you are defining "B" to use what ever A happens to exist
>>>> at the moment. B isn't a computation or even a program by the normal
>>>> definition of one.
>>>>
>>>> In this case, I would say you are correct to say that THIS problem
>>>> is "invalid", due to the automagically changing input as you change
>>>> the decider looking at it.
>>>>
>>>> Of course, since the REAL Haltng problem doesn't do that, it is
>>>> still valid.
>>>>
>>>>>
>>>>>>>
>>>>>>>> You are just playing with words again.
>>>>>>>>
>>>>>>>> To be a Halt Decider, the output needs to match the Halting
>>>>>>>> Function.
>>>>>>>>
>>>>>>> I will agree that is the common understanding.
>>>>>>> The is no preexisting common understanding of a simulating abort
>>>>>>> decider because (to the best of my knowledge) no one every thought
>>>>>>> of this before.
>>>>>>
>>>>>> And either it is equivalent, or it isn't. If it isn't, then it
>>>>>> says nothing about the Halting Problem.
>>>>>>
>>>>>
>>>>> It is too disingenuous to say that it say nothing about the halting
>>>>> problem. It as much as solves a different version of the halting
>>>>> problem.
>>>>
>>>> Which isn't the Halting Problem. Something that isn't the Halting
>>>> Problem doesn't say much about the actual Halting Problem.
>>>>
>>>> Now, if you want to try to actually formally define your
>>>> differences, and some how show that they are actually minor and
>>>> insignificant, you might be able to do something, but when you throw
>>>> out fundamental principles. liek a program is what the program is,
>>>> you are just lying about what you are doing.
>>>>
>>>>>
>>>>> If the original version is incoherent the same sort of way that Naive
>>>>> set theory allowed Russell's Paradox then an abort decider corrects
>>>>> the erroneous halting problem that same way that ZFC corrected Naive
>>>>> set theory.
>>>>>
>>>>>> Since the only rational definition of "Needs to Abort its
>>>>>> simulation", is that a correct simulation of the input would not
>>>>>> halt, then your "abort deciders" turn out to need to be actually
>>>>>> Halt Decider.
>>>>>>
>>>>>
>>>>> An abort decider <is> a halt decider from its own point of view.
>>>>> It is not and cannot be a halt decider from any other POV.
>>>>
>>>> Only by lying to itself.
>>>>
>>>> Since Halt Deciding is a OBJECTIVE criteria, it can't be equivalent,
>>>> or even very similar to your SUBJECTIVE new criteria, which you
>>>> can't even properly define, since you keep on with your using of
>>>> non-algorithmic terms to describe what it is to do.
>>>>
>>>>>
>>>>>> The logic of looking at what would happen if H was a different
>>>>>> machine ib a way that actually changed the behavior of the input
>>>>>> (because you either make the input not a computation, or re-write
>>>>>> the input) is ust invalid.
>>>>>>
>>>>>
>>>>> The whole class of every H(D,D) that simulates its input
>>>>> is divided into two sub-classes:
>>>>> (a) H(D,D) that DOES NOT abort its simulation is incorrect
>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>      because it would never halt and all deciders must always halt.
>>>>>
>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>      because it would halt and all deciders must always halt.
>>>>
>>>> So, it is a DECIDER, but you haven't proven it is a CORRECT decider
>>>> about any defined mapping (other than the trivial problem of it maps
>>>> what it generates).
>>>>
>>>
>>> I haven't bothered to repeat this again because you far too consistently
>>> deny easily verified facts. By whatever process that you can tell that
>>> every member of (a) is incorrect and every member of (b) is correct is
>>> the same one that H uses.
>>
>> Nope. JUST MORE LIES showing your utter stupidity.
>>
>>>
>>> It took you far too long to acknowledge what you did and I am concerned
>>> for your soul. Getting caught up in childish head games may be quite fun
>>> yet not at the expense of your soul.
>>
>> I am concerned for YOUR soul, but fear you may be too far gone, since
>> you have clearly fallen for the devils lies.
>>
>>>
>>>> Your logic ignores that D changes its behavior based on the H that
>>>> it uses,
>>>
>>> *I have known this for two years and you have denied this for two years*
>>
>> But if D changes its behavior based on the H it calls, then looking at
>> it with ANY H other than the one that is the one that you claim to
>> give the right answer is just a LIE.
>>
>> And That H does what it DOES, and doesn't "Correctly Simulate" the
>> input to the point that shows that the input is non-halting, and every
>> logic you have shown is based on LYING that the H that you are working
>> with, which is actually a different H than you final H, is somehow
>> "the same" even though it uses a different one.
>>
>> So, your arguement is just filled with LIES.
>>
>>>
>>>> so the fact that a D in group a, and thus using a group a H is not
>>>> halting says nothing about a a in group b,
>>>
>>> Every element of (a) is incorrect thus making every element of (b)
>>> correct about the abort decision.
>>
>>
>> NOPE. JUST MORE LIES.
>>
>> Proving you are totally STUPID.
>>
>>>
>>>> and thus using a group b H. It can be shown that all these D are
>>>> HALTING, and thus there decider does NOT need to abort its
>>>> simulation, even though it DOES.
>>>>
>>>>>
>>>>> Fred is seeming to understand this now.
>>>>> On 3/26/2024 6:23 AM, Fred. Zwarts wrote:
>>>>>  > 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.
>>>>>
>>>>>>>
>>>>>>> When-so-ever a simulating abort decider correctly determines in N
>>>>>>> steps of correct simulation that the behavior of its input matches
>>>>>>> a correct predefined non-halting behavior pattern the abort decider
>>>>>>> is always correct to abort the simulation of this input.
>>>>>>
>>>>>> Except there is no "correct predefined non-halting behavior
>>>>>> pattern" that exists in the simulation of this D(D), since that
>>>>>> input WILL HALT if the H that it is built on tries to take ANY of
>>>>>> the patterns that are reached in the simulation, to abort and
>>>>>> return 0.
>>>>>>
>>>>>> This was proven a couple of YEARS ago, and you ignored it, because
>>>>>> it was just an inconvienent truth.
>>>>>>
>>>>>> Your logic is based on ASSUME SOMETHING TO EXIST, even if you can
>>>>>> not prove that it does. That is just UNSOUND logic, showing that
>>>>>> you have an UNSOUND logic system.
>>>>>>
>>>>>>>
>>>>>>>> To be an Abort Decider, the output needs to match the correct
>>>>>>>> definition of an Abort Decider, namely would the correct
>>>>>>>> simulation of the input halt in a finite number of steps, or
>>>>>>>> does the correct simulation need to be aborted to come to an end,
>>>>>>>>
>>>>>>> Something like that. Would simulated D stop running on its own
>>>>>>> without ever having its simulation aborted?
>>>>>>
>>>>>> Right, but the D MUST be based on the ACTUAL H that you claim
>>>>>> gives the right answer. If that does abort, then you MUST give the
>>>>>> input to a DIFFERENT simulator, while keeping its pairing to that H.
>>>>>>
>>>>>>>
>>>>>>> Because you continue to lie about H(D,D) needing to abort its
>>>>>>> simulation
>>>>>>> we are not getting to the point where we can see if any input
>>>>>>> could fool
>>>>>>> an abort decider into getting the wrong abort decision answer.
>>>>>>>
>>>>>>
>>>>>> But I have shown that the H(D,D) that aborts and returns 0, does
>>>>>> not need to actually abort its simulation.
>>>>>
>>>>> *I really can't see how that is not simply a lie*
>>>>> *I really can't see how that is not simply a lie*
>>>>> *I really can't see how that is not simply a lie*
>>>>>
>>>>>
>>>>
>>>> Yes, you can't, because you lie to yourself about the meaning of the
>>>> words.
>>>>
>>>
>>> I simply take key verses 100% literally as if God would always
>>> say 100% exactly what he means and always means exactly 100% of
>>> what he says. I am not aware of anyone else that does this.
>>
>> Which is the DEVIL'S way to read the Bible.
>>
>> Look at his example of Tempting Jesus in the desert. Quoting
>> scriptures out of context, and trying to offer a LITERAL meaning that
>> differed from the actual meaning, that Jesus pointed out by his reply.
>>
>>>
>>> If one does not do this then the bible can be taken in too many
>>> different ways.
>>
>> Nope.
>>
>> YOUR way allows all the variation,
>>
>>>
>>> All of the different denominations having their differing views
>>> proves that (at least) to the extent that they differ they are
>>> incorrect.
>>
>> And the key is to actually STUDY to see what is the REAL truth behind
>> all the variations, and what differences are important, and what are
>> actually insubstantial.
>>
>> When you actually KNOW what the Bible says, and talk to others who
>> also KNOW what the Bible says, you can discuss things with people even
>> from very dofferent backgrounds, and find agreement.
>>
>> You get the big disagreements from people who don't actually know the
>> Bible, but just the "Dogma" of their religious community. These are
>> not really beleivers or possibly not even really "Christians" that
>> Christ will take in the last day.
>>
>
> It seems to me that all those things that do not pertain to
> righteousness can be ignored.

On 3/28/2024 6:59 AM, Richard Damon wrote:
> On 3/27/24 11:58 PM, olcott wrote:
>> On 3/27/2024 9:34 PM, Richard Damon wrote:
>>> On 3/27/24 10:07 PM, olcott wrote:
>>>> On 3/27/2024 7:48 PM, Richard Damon wrote:
>>>>> On 3/26/24 11:10 PM, olcott wrote:
>>>>>> On 3/26/2024 9:18 PM, Richard Damon wrote:
>>>>>>> On 3/26/24 11:33 AM, olcott wrote:
>>>>>>>> On 3/26/2024 6:43 AM, Richard Damon wrote:
>>>>>>>>> On 3/25/24 11:29 PM, olcott wrote:
>>>>>>>>>> On 3/25/2024 10:01 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/25/24 10:53 PM, olcott wrote:
>>>>>>>>>>>> On 3/25/2024 9:08 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/25/24 9:35 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/25/2024 8:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/25/24 9:12 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/25/2024 7:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/25/24 8:37 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/25/2024 7:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/25/24 8:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/25/2024 6:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>> be fooled by any pathological input?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int
>>>>>>>>>>>>>>>>>>>>>>>>>>>> function
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Of all of the elements of the set of H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> where H simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input there are matched pairs of otherwise
>>>>>>>>>>>>>>>>>>>>>>>>>>>> identical elements that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> only differ by whether they abort their
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or not.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The half of these that don't abort are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect because all deciders
>>>>>>>>>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> about the abort/no abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No. The other, aborting, half is just wrong,
>>>>>>>>>>>>>>>>>>>>>>>>>>> because it aborts when it is not needed. So,
>>>>>>>>>>>>>>>>>>>>>>>>>>> the half that aborts is wrong and it may be
>>>>>>>>>>>>>>>>>>>>>>>>>>> argued that it is better to not abort
>>>>>>>>>>>>>>>>>>>>>>>>>>> something that halts on its own and that
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> At least two software engineers with masters
>>>>>>>>>>>>>>>>>>>>>>>>>> degrees in computer science
>>>>>>>>>>>>>>>>>>>>>>>>>> disagree.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Two is not many, considering that with Google
>>>>>>>>>>>>>>>>>>>>>>>>> for any invalid idea it is easy to find a
>>>>>>>>>>>>>>>>>>>>>>>>> several people with a master degree supporting it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Exactly what are you software engineering skills?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I have been professionally programming since
>>>>>>>>>>>>>>>>>>>>>>>>> 1986 in several languages. (Non professionally
>>>>>>>>>>>>>>>>>>>>>>>>> I started programming in 1975). Since about
>>>>>>>>>>>>>>>>>>>>>>>>> 1990 I programmed in C and since about 2000 in
>>>>>>>>>>>>>>>>>>>>>>>>> C++.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have been a professional C++ software
>>>>>>>>>>>>>>>>>>>>>>>>>> engineer since Y2K.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I'm sorry to hear that olcott has been so
>>>>>>>>>>>>>>>>>>>>>>>>> smart, but now he does not even sees what even
>>>>>>>>>>>>>>>>>>>>>>>>> a beginner sees.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>>>>>>>>> 09 void main()
>>>>>>>>>>>>>>>>>>>>>>>> 10 {
>>>>>>>>>>>>>>>>>>>>>>>> 11   H(D,D);
>>>>>>>>>>>>>>>>>>>>>>>> 12 }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *Execution Trace*
>>>>>>>>>>>>>>>>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>>>>>>>>>>>>>>>>> Line 03: simulated D(D) invokes simulated H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>> that simulates D(D)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Even a beginner sees that, if the H that aborts
>>>>>>>>>>>>>>>>>>>>>>> is chosen, simulated H(D,D) aborts and returns
>>>>>>>>>>>>>>>>>>>>>>> false (unless aborted). So simulated D halts
>>>>>>>>>>>>>>>>>>>>>>> (unless aborted).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I am estimating that you must be fibbing about
>>>>>>>>>>>>>>>>>>>>>> your programming skill.
>>>>>>>>>>>>>>>>>>>>>> The D simulated by any implementation of H (that
>>>>>>>>>>>>>>>>>>>>>> aborts or does not
>>>>>>>>>>>>>>>>>>>>>> abort its simulation) shown above cannot possibly
>>>>>>>>>>>>>>>>>>>>>> reach its own line 04
>>>>>>>>>>>>>>>>>>>>>> also shown above.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But that isn't the question.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *That <is> the abort decision question*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But you agreed that a correct abort decider oly NEEDS
>>>>>>>>>>>>>>>>>>> to abort its simulation if the correct simulation by
>>>>>>>>>>>>>>>>>>> a pure correct simulator of the input given to H
>>>>>>>>>>>>>>>>>>> (which doesn't change, so for this case, still calls
>>>>>>>>>>>>>>>>>>> that original H) will never reach a final state.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The question is does that machine described by the
>>>>>>>>>>>>>>>>>>>>> input Halt when run, or, alternatively, does its
>>>>>>>>>>>>>>>>>>>>> correct simulation (not just by H) run forever (and
>>>>>>>>>>>>>>>>>>>>> thus needs to be aborted)?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Since you know that H(D,D) must abort its simulation
>>>>>>>>>>>>>>>>>>>> to prevent its
>>>>>>>>>>>>>>>>>>>> own infinite execution I don't understand why you
>>>>>>>>>>>>>>>>>>>> would lie about it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But an H that doesn't abort and an H that does abort
>>>>>>>>>>>>>>>>>>> are looking at different inputs "D", since you agree
>>>>>>>>>>>>>>>>>>> that the behavior of D changes based on the H that it
>>>>>>>>>>>>>>>>>>> is using.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Not at all. Of the infinite set of every possible
>>>>>>>>>>>>>>>>>> implementation of
>>>>>>>>>>>>>>>>>> H where H(D,D) simulates its input everyone that chose
>>>>>>>>>>>>>>>>>> to abort is
>>>>>>>>>>>>>>>>>> necessarily correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I don't understand why you persist in lying about this.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I really want to get on to the next step and see if
>>>>>>>>>>>>>>>>>>>> any input can
>>>>>>>>>>>>>>>>>>>> fool an abort decider into making the wrong abort
>>>>>>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But you need to get this step right first.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Perhaps you already know that you are not up to this
>>>>>>>>>>>>>>>>>>>> challenge?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, it seems that YOU are not up to it, as you can't
>>>>>>>>>>>>>>>>>>> seem to understand the error that you are making.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You keep on lying to yourself about what your
>>>>>>>>>>>>>>>>>>> requirements are.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I am not the one that keeps using the strawman
>>>>>>>>>>>>>>>>>> deception to change
>>>>>>>>>>>>>>>>>> the subject away from H(D,D) an abort decider for the
>>>>>>>>>>>>>>>>>> above D.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Neither am I.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> YOU agreed that the criteria for an abort decider is
>>>>>>>>>>>>>>>>> only CORRECT if a CORRECT simulation of the exact input
>>>>>>>>>>>>>>>>> given to H(D,D) (i.e UTM(D,D) ) does not halt, where D
>>>>>>>>>>>>>>>>> still calls that H(D,D)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I never agreed to that.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes you did:
>>>>>>>>>>>>
>>>>>>>>>>>> *You just admitted to lying abut this* (see below).
>>>>>>>>>>>
>>>>>>>>>>> Nope, see below.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>>>>>>>>>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>  >> To me, for H to NEED to abort its simulation, that
>>>>>>>>>>>>>>> means that when giving the input to a correct simulator,
>>>>>>>>>>>>>>> that simulator will not halt.
>>>>>>>>>>>>>>>  >>
>>>>>>>>>>>>>>>  > Yes that is correct.
>>>>>>>>>>>>>>>  >
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since the ONLY definition of a "Correct Simulator" is a
>>>>>>>>>>>>>>> simulator that never aborts, you did..
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because we have been over this hundreds of times you know
>>>>>>>>>>>>>> that I mean
>>>>>>>>>>>>>> that a correct simulator means that every step that H
>>>>>>>>>>>>>> simulates was
>>>>>>>>>>>>>> correctly simulated, so why are you lying about this now?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Are you trying to run out the clock on my rebuttals?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And YOU know that when *I* say "Correct Simulation", I mean
>>>>>>>>>>>>> per the definition of a UTM that exactly duplicates the
>>>>>>>>>>>>> full behavior of the input machine, and you agreed to ME.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then you are admitting that you lied when you claimed that
>>>>>>>>>>>> I believed that.
>>>>>>>>>>>
>>>>>>>>>>> YOU agreed with what *I* said. When I speak, words mean what
>>>>>>>>>>> *I* hold them to beleive.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Are you really willing to bet your soul on that?
>>>>>>>>>
>>>>>>>>> As I said, YES, but are you?
>>>>>>>>>
>>>>>>>> Seems foolish to me. I never bet what I cannot afford to lose.
>>>>>>>> Maybe you should ask the leadership of your church about this.
>>>>>>>
>>>>>>> But I know I can't lose, because I know of the promise of God and
>>>>>>> that he has written my name in his Book of Life.
>>>>>>>
>>>>>>>>
>>>>>>>>> Or does the fact that you already lost it mean it doesn't
>>>>>>>>> matter to you.
>>>>>>>>>
>>>>>>>> That is not what scripture says.
>>>>>>>
>>>>>>> It does, but you do not understand it.
>>>>>>>
>>>>>>> You seem to have reached the point where God has turned you over
>>>>>>> to your own desires, giving you the taste of eternal hell here,
>>>>>>> to see if you will repent.
>>>>>>>
>>>>>>> If you do, you can claim your soul back, but for now, YOU have
>>>>>>> given it to the devil.
>>>>>>>
>>>>>
>>>>> So, you now go and show that you will also LIE about the meaning of
>>>>> verses in the Bible.
>>>>>
>>>>> You are going to show that just as you try to misinterprete the
>>>>> works of the great logicitians that have proved things you don't
>>>>> like, you are also going to misinterpete the Bible to try to
>>>>> juistify your own ideas.
>>>>>
>>>>> You are just Proof-Texting and doing Eisogesis on the text, instead
>>>>> of Exegesis to discover the actual meaning.
>>>>>
>>>>>>
>>>>>> Galatians 5:14 NRSV
>>>>>> For the whole law is summed up in a single commandment,
>>>>>> “You shall love your neighbor as yourself.”
>>>>>
>>>>> Remember, Galatians was written to a CHURCH of BELIEVERS, who were
>>>>> suffering some persecution. There was a movement to try to push
>>>>> them back to "Old Testament Judiasm", which was a Key part of
>>>>> Paul's discourse. Being Beleivers, talking about the need to love
>>>>> God, wasn't an issue, but pointing out that the ceremonial law and
>>>>> animal sacrifice system was no longer applicable, because it had
>>>>> been fulfilled. The MORAL law, which is the part that derives from
>>>>> the "Second Greatest Commandment"
>>>>>
>>>>>  From Matthew 22:37 Jesus replied: “ ‘Love the Lord your God with
>>>>> all your heart and with all your soul and with all your mind.’ 38
>>>>> This is the first and greatest commandment. And the second is like
>>>>> it: ‘Love your neighbor as yourself.’ All the Law and the Prophets
>>>>> hang on these two commandments.”
>>>>>
>>>>> Paul can help interprete Jesus, but can not change his meaning.
>>>>>
>>>>>>
>>>>>> Isaiah 45:6
>>>>>> That they may know from the rising of the sun, and from
>>>>>> the west, that there is none beside me. I am the Lord, and
>>>>>> there is none else.
>>>>>>
>>>>>> When one takes the above two verses 100% literally as if
>>>>>> they were a mathematical specification one gets an entirely
>>>>>> different meaning than everyone else gets.
>>>>>
>>>>> But 100% literal is NOT how you need to take the verses of the Bible.
>>>>>
>>>>>>
>>>>>> I checked the last very with two Hebrew bible scholars and
>>>>>> they both agree that it says nothing besides God actually
>>>>>> exists.
>>>>>
>>>>> So? Interpreting a verse out of context is just a pretext.
>>>>>
>>>>>>
>>>>>> All those lead by the Holy Spirit are on the right path. I
>>>>>> am doing what I can for additional spiritual confirmation.
>>>>>
>>>>> I seriously doubt you are being lead by the HOLY Spirit, as he can
>>>>> not stand to be with a liar.
>>>>>
>>>>> OR someone who blasphemes God by claiming to be comparable.
>>>>>
>>>>> It is likely some other "spirit" guiding you to that lake of fire.
>>>>>
>>>>>
>>>>>>
>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> Thus, YOU AGREED to MY definition, since you agrees with NO
>>>>>>>>>>> qualifications of your statement.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU definition is just illogical as it means that the
>>>>>>>>>>>>> behavior of a machine is determined by the behavior of a
>>>>>>>>>>>>> machine that is not it.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Because deciders must always halt every H that never halts
>>>>>>>>>>>> has incorrect
>>>>>>>>>>>> halting behavior and every H that halts has correct halting
>>>>>>>>>>>> behavior.
>>>>>>>>>>>
>>>>>>>>>>> That isn't what a "Halt Decider" means, and you are just
>>>>>>>>>>> proving you are just STUPID.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So now you are disagreeing that ALL deciders must always halt?
>>>>>>>>>
>>>>>>>>> Nope, but Halting isn't enough to make a foo decider a foo
>>>>>>>>> decider.
>>>>>>>>>
>>>>>>>> Sure I can certainly agree with that.
>>>>>>>
>>>>>>> So, the fact that you deciders just Halt, doesn't make the
>>>>>>> correct Halt Deciders, they are only that if their answer to
>>>>>>> H(M,d) matchs Halts(M,d) for all M and d, or for this particular
>>>>>>> case H(D,D) must match Halts(D,D), which is doesn't, so they are
>>>>>>> not correct halt deciders.
>>>>>>>
>>>>>>
>>>>>> // A is an abort decider
>>>>>
>>>>>
>>>>>
>>>>>> 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.
>>>>>>
>>>>>> When-so-ever a simulating abort decider correctly determines in N
>>>>>> steps of correct simulation that the behavior of its input matches
>>>>>> a correct predefined non-halting behavior pattern the abort decider
>>>>>> is always correct to abort the simulation of this input.
>>>>>
>>>>> So, does A have a SPECIFIC set of code that it is running?
>>>>>
>>>>> If not, your whole arguement is just a LIE.
>>>>>
>>>>> If it does, how can it determine what it would do if it doesn't do
>>>>> what it does, that would be something else, not it.
>>>>>
>>>>> And, since you are defining "B" to use what ever A happens to exist
>>>>> at the moment. B isn't a computation or even a program by the
>>>>> normal definition of one.
>>>>>
>>>>> In this case, I would say you are correct to say that THIS problem
>>>>> is "invalid", due to the automagically changing input as you change
>>>>> the decider looking at it.
>>>>>
>>>>> Of course, since the REAL Haltng problem doesn't do that, it is
>>>>> still valid.
>>>>>
>>>>>>
>>>>>>>>
>>>>>>>>> You are just playing with words again.
>>>>>>>>>
>>>>>>>>> To be a Halt Decider, the output needs to match the Halting
>>>>>>>>> Function.
>>>>>>>>>
>>>>>>>> I will agree that is the common understanding.
>>>>>>>> The is no preexisting common understanding of a simulating abort
>>>>>>>> decider because (to the best of my knowledge) no one every thought
>>>>>>>> of this before.
>>>>>>>
>>>>>>> And either it is equivalent, or it isn't. If it isn't, then it
>>>>>>> says nothing about the Halting Problem.
>>>>>>>
>>>>>>
>>>>>> It is too disingenuous to say that it say nothing about the halting
>>>>>> problem. It as much as solves a different version of the halting
>>>>>> problem.
>>>>>
>>>>> Which isn't the Halting Problem. Something that isn't the Halting
>>>>> Problem doesn't say much about the actual Halting Problem.
>>>>>
>>>>> Now, if you want to try to actually formally define your
>>>>> differences, and some how show that they are actually minor and
>>>>> insignificant, you might be able to do something, but when you
>>>>> throw out fundamental principles. liek a program is what the
>>>>> program is, you are just lying about what you are doing.
>>>>>
>>>>>>
>>>>>> If the original version is incoherent the same sort of way that Naive
>>>>>> set theory allowed Russell's Paradox then an abort decider corrects
>>>>>> the erroneous halting problem that same way that ZFC corrected Naive
>>>>>> set theory.
>>>>>>
>>>>>>> Since the only rational definition of "Needs to Abort its
>>>>>>> simulation", is that a correct simulation of the input would not
>>>>>>> halt, then your "abort deciders" turn out to need to be actually
>>>>>>> Halt Decider.
>>>>>>>
>>>>>>
>>>>>> An abort decider <is> a halt decider from its own point of view.
>>>>>> It is not and cannot be a halt decider from any other POV.
>>>>>
>>>>> Only by lying to itself.
>>>>>
>>>>> Since Halt Deciding is a OBJECTIVE criteria, it can't be
>>>>> equivalent, or even very similar to your SUBJECTIVE new criteria,
>>>>> which you can't even properly define, since you keep on with your
>>>>> using of non-algorithmic terms to describe what it is to do.
>>>>>
>>>>>>
>>>>>>> The logic of looking at what would happen if H was a different
>>>>>>> machine ib a way that actually changed the behavior of the input
>>>>>>> (because you either make the input not a computation, or re-write
>>>>>>> the input) is ust invalid.
>>>>>>>
>>>>>>
>>>>>> The whole class of every H(D,D) that simulates its input
>>>>>> is divided into two sub-classes:
>>>>>> (a) H(D,D) that DOES NOT abort its simulation is incorrect
>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>      because it would never halt and all deciders must always halt.
>>>>>>
>>>>>> (b) H(D,D) that DOES abort its simulation is correct
>>>>>>      (ABOUT THIS ABORT DECISION)
>>>>>>      because it would halt and all deciders must always halt.
>>>>>
>>>>> So, it is a DECIDER, but you haven't proven it is a CORRECT decider
>>>>> about any defined mapping (other than the trivial problem of it
>>>>> maps what it generates).
>>>>>
>>>>
>>>> I haven't bothered to repeat this again because you far too
>>>> consistently
>>>> deny easily verified facts. By whatever process that you can tell that
>>>> every member of (a) is incorrect and every member of (b) is correct is
>>>> the same one that H uses.
>>>
>>> Nope. JUST MORE LIES showing your utter stupidity.
>>>
>>>>
>>>> It took you far too long to acknowledge what you did and I am concerned
>>>> for your soul. Getting caught up in childish head games may be quite
>>>> fun
>>>> yet not at the expense of your soul.
>>>
>>> I am concerned for YOUR soul, but fear you may be too far gone, since
>>> you have clearly fallen for the devils lies.
>>>
>>>>
>>>>> Your logic ignores that D changes its behavior based on the H that
>>>>> it uses,
>>>>
>>>> *I have known this for two years and you have denied this for two
>>>> years*
>>>
>>> But if D changes its behavior based on the H it calls, then looking
>>> at it with ANY H other than the one that is the one that you claim to
>>> give the right answer is just a LIE.
>>>
>>> And That H does what it DOES, and doesn't "Correctly Simulate" the
>>> input to the point that shows that the input is non-halting, and
>>> every logic you have shown is based on LYING that the H that you are
>>> working with, which is actually a different H than you final H, is
>>> somehow "the same" even though it uses a different one.
>>>
>>> So, your arguement is just filled with LIES.
>>>
>>>>
>>>>> so the fact that a D in group a, and thus using a group a H is not
>>>>> halting says nothing about a a in group b,
>>>>
>>>> Every element of (a) is incorrect thus making every element of (b)
>>>> correct about the abort decision.
>>>
>>>
>>> NOPE. JUST MORE LIES.
>>>
>>> Proving you are totally STUPID.
>>>
>>>>
>>>>> and thus using a group b H. It can be shown that all these D are
>>>>> HALTING, and thus there decider does NOT need to abort its
>>>>> simulation, even though it DOES.
>>>>>
>>>>>>
>>>>>> Fred is seeming to understand this now.
>>>>>> On 3/26/2024 6:23 AM, Fred. Zwarts wrote:
>>>>>>  > 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.
>>>>>>
>>>>>>>>
>>>>>>>> When-so-ever a simulating abort decider correctly determines in N
>>>>>>>> steps of correct simulation that the behavior of its input matches
>>>>>>>> a correct predefined non-halting behavior pattern the abort decider
>>>>>>>> is always correct to abort the simulation of this input.
>>>>>>>
>>>>>>> Except there is no "correct predefined non-halting behavior
>>>>>>> pattern" that exists in the simulation of this D(D), since that
>>>>>>> input WILL HALT if the H that it is built on tries to take ANY of
>>>>>>> the patterns that are reached in the simulation, to abort and
>>>>>>> return 0.
>>>>>>>
>>>>>>> This was proven a couple of YEARS ago, and you ignored it,
>>>>>>> because it was just an inconvienent truth.
>>>>>>>
>>>>>>> Your logic is based on ASSUME SOMETHING TO EXIST, even if you can
>>>>>>> not prove that it does. That is just UNSOUND logic, showing that
>>>>>>> you have an UNSOUND logic system.
>>>>>>>
>>>>>>>>
>>>>>>>>> To be an Abort Decider, the output needs to match the correct
>>>>>>>>> definition of an Abort Decider, namely would the correct
>>>>>>>>> simulation of the input halt in a finite number of steps, or
>>>>>>>>> does the correct simulation need to be aborted to come to an end,
>>>>>>>>>
>>>>>>>> Something like that. Would simulated D stop running on its own
>>>>>>>> without ever having its simulation aborted?
>>>>>>>
>>>>>>> Right, but the D MUST be based on the ACTUAL H that you claim
>>>>>>> gives the right answer. If that does abort, then you MUST give
>>>>>>> the input to a DIFFERENT simulator, while keeping its pairing to
>>>>>>> that H.
>>>>>>>
>>>>>>>>
>>>>>>>> Because you continue to lie about H(D,D) needing to abort its
>>>>>>>> simulation
>>>>>>>> we are not getting to the point where we can see if any input
>>>>>>>> could fool
>>>>>>>> an abort decider into getting the wrong abort decision answer.
>>>>>>>>
>>>>>>>
>>>>>>> But I have shown that the H(D,D) that aborts and returns 0, does
>>>>>>> not need to actually abort its simulation.
>>>>>>
>>>>>> *I really can't see how that is not simply a lie*
>>>>>> *I really can't see how that is not simply a lie*
>>>>>> *I really can't see how that is not simply a lie*
>>>>>>
>>>>>>
>>>>>
>>>>> Yes, you can't, because you lie to yourself about the meaning of
>>>>> the words.
>>>>>
>>>>
>>>> I simply take key verses 100% literally as if God would always
>>>> say 100% exactly what he means and always means exactly 100% of
>>>> what he says. I am not aware of anyone else that does this.
>>>
>>> Which is the DEVIL'S way to read the Bible.
>>>
>>> Look at his example of Tempting Jesus in the desert. Quoting
>>> scriptures out of context, and trying to offer a LITERAL meaning that
>>> differed from the actual meaning, that Jesus pointed out by his reply.
>>>
>>>>
>>>> If one does not do this then the bible can be taken in too many
>>>> different ways.
>>>
>>> Nope.
>>>
>>> YOUR way allows all the variation,
>>>
>>>>
>>>> All of the different denominations having their differing views
>>>> proves that (at least) to the extent that they differ they are
>>>> incorrect.
>>>
>>> And the key is to actually STUDY to see what is the REAL truth behind
>>> all the variations, and what differences are important, and what are
>>> actually insubstantial.
>>>
>>> When you actually KNOW what the Bible says, and talk to others who
>>> also KNOW what the Bible says, you can discuss things with people
>>> even from very dofferent backgrounds, and find agreement.
>>>
>>> You get the big disagreements from people who don't actually know the
>>> Bible, but just the "Dogma" of their religious community. These are
>>> not really beleivers or possibly not even really "Christians" that
>>> Christ will take in the last day.
>>>
>>
>> It seems to me that all those things that do not pertain to
>> righteousness can be ignored.
>
> Righteousness is having a Right Relationship to God. Ignoring who he is
> makes that impossible.
>
>>
>> Things such as this:
>> Is the Godhead three different beings or one being taking three forms?
>>
>
> But not correctly understanding who he is makes it impossible to have a
> right relationship to him.
>
Many churches differ on the trinity.

On 3/28/24 10:53 AM, olcott wrote:
> On 3/28/2024 6:59 AM, Richard Damon wrote:
>> On 3/27/24 11:58 PM, olcott wrote:
>>> On 3/27/2024 9:34 PM, Richard Damon wrote:
>>>> On 3/27/24 10:07 PM, olcott wrote:
>>>>> All of the different denominations having their differing views
>>>>> proves that (at least) to the extent that they differ they are
>>>>> incorrect.
>>>>
>>>> And the key is to actually STUDY to see what is the REAL truth
>>>> behind all the variations, and what differences are important, and
>>>> what are actually insubstantial.
>>>>
>>>> When you actually KNOW what the Bible says, and talk to others who
>>>> also KNOW what the Bible says, you can discuss things with people
>>>> even from very dofferent backgrounds, and find agreement.
>>>>
>>>> You get the big disagreements from people who don't actually know
>>>> the Bible, but just the "Dogma" of their religious community. These
>>>> are not really beleivers or possibly not even really "Christians"
>>>> that Christ will take in the last day.
>>>>
>>>
>>> It seems to me that all those things that do not pertain to
>>> righteousness can be ignored.
>>
>> Righteousness is having a Right Relationship to God. Ignoring who he
>> is makes that impossible.
>>
>>>
>>> Things such as this:
>>> Is the Godhead three different beings or one being taking three forms?
>>>
>>
>> But not correctly understanding who he is makes it impossible to have
>> a right relationship to him.
>>
> Many churches differ on the trinity.

Right, and just like you point out that many people may claim to be
"Christians" but are not living a "Christian Life", many churches have
also formed based on wrong ideas about the Bible.

One of Satan's best methods is to get people to think they are "sage" in
a Church, even thought ath Church isn't actually teaching them the truth.

There are also a number of things that don't have a "single"
interpretation that must be followed, but different people can
legitimately worship God acceptably in different ways.

>
>> Yes, there are details that we do not need to (or in fact can not)
>> understand.
>>
>> But God expects us to do all that we have the power to do, then he can
>> do the rest.
>>
>> Intentionally neglecting what he says, puts you outside his Grace.
>>
>
>

On 3/28/2024 7:07 PM, Richard Damon wrote:
> On 3/28/24 10:53 AM, olcott wrote:
>> On 3/28/2024 6:59 AM, Richard Damon wrote:
>>> On 3/27/24 11:58 PM, olcott wrote:
>>>> On 3/27/2024 9:34 PM, Richard Damon wrote:
>>>>> On 3/27/24 10:07 PM, olcott wrote:
>>>>>> All of the different denominations having their differing views
>>>>>> proves that (at least) to the extent that they differ they are
>>>>>> incorrect.
>>>>>
>>>>> And the key is to actually STUDY to see what is the REAL truth
>>>>> behind all the variations, and what differences are important, and
>>>>> what are actually insubstantial.
>>>>>
>>>>> When you actually KNOW what the Bible says, and talk to others who
>>>>> also KNOW what the Bible says, you can discuss things with people
>>>>> even from very dofferent backgrounds, and find agreement.
>>>>>
>>>>> You get the big disagreements from people who don't actually know
>>>>> the Bible, but just the "Dogma" of their religious community. These
>>>>> are not really beleivers or possibly not even really "Christians"
>>>>> that Christ will take in the last day.
>>>>>
>>>>
>>>> It seems to me that all those things that do not pertain to
>>>> righteousness can be ignored.
>>>
>>> Righteousness is having a Right Relationship to God. Ignoring who he
>>> is makes that impossible.
>>>
>>>>
>>>> Things such as this:
>>>> Is the Godhead three different beings or one being taking three forms?
>>>>
>>>
>>> But not correctly understanding who he is makes it impossible to have
>>> a right relationship to him.
>>>
>> Many churches differ on the trinity.
>
> Right, and just like you point out that many people may claim to be
> "Christians" but are not living a "Christian Life", many churches have
> also formed based on wrong ideas about the Bible.
>
> One of Satan's best methods is to get people to think they are "sage" in
> a Church, even thought ath Church isn't actually teaching them the truth.
>

What is the infallible process to distinguish the difference?

> There are also a number of things that don't have a "single"
> interpretation that must be followed, but different people can
> legitimately worship God acceptably in different ways.
>
>>
>>> Yes, there are details that we do not need to (or in fact can not)
>>> understand.
>>>
>>> But God expects us to do all that we have the power to do, then he
>>> can do the rest.
>>>
>>> Intentionally neglecting what he says, puts you outside his Grace.
>>>
>>
>>
>

--
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/28/24 9:42 PM, olcott wrote:
> On 3/28/2024 7:07 PM, Richard Damon wrote:
>> On 3/28/24 10:53 AM, olcott wrote:
>>> On 3/28/2024 6:59 AM, Richard Damon wrote:
>>>> On 3/27/24 11:58 PM, olcott wrote:
>>>>> On 3/27/2024 9:34 PM, Richard Damon wrote:
>>>>>> On 3/27/24 10:07 PM, olcott wrote:
>>>>>>> All of the different denominations having their differing views
>>>>>>> proves that (at least) to the extent that they differ they are
>>>>>>> incorrect.
>>>>>>
>>>>>> And the key is to actually STUDY to see what is the REAL truth
>>>>>> behind all the variations, and what differences are important, and
>>>>>> what are actually insubstantial.
>>>>>>
>>>>>> When you actually KNOW what the Bible says, and talk to others who
>>>>>> also KNOW what the Bible says, you can discuss things with people
>>>>>> even from very dofferent backgrounds, and find agreement.
>>>>>>
>>>>>> You get the big disagreements from people who don't actually know
>>>>>> the Bible, but just the "Dogma" of their religious community.
>>>>>> These are not really beleivers or possibly not even really
>>>>>> "Christians" that Christ will take in the last day.
>>>>>>
>>>>>
>>>>> It seems to me that all those things that do not pertain to
>>>>> righteousness can be ignored.
>>>>
>>>> Righteousness is having a Right Relationship to God. Ignoring who he
>>>> is makes that impossible.
>>>>
>>>>>
>>>>> Things such as this:
>>>>> Is the Godhead three different beings or one being taking three forms?
>>>>>
>>>>
>>>> But not correctly understanding who he is makes it impossible to
>>>> have a right relationship to him.
>>>>
>>> Many churches differ on the trinity.
>>
>> Right, and just like you point out that many people may claim to be
>> "Christians" but are not living a "Christian Life", many churches have
>> also formed based on wrong ideas about the Bible.
>>
>> One of Satan's best methods is to get people to think they are "sage"
>> in a Church, even thought ath Church isn't actually teaching them the
>> truth.
>>
>
> What is the infallible process to distinguish the difference?

Testing the spirit against an honest interpretation of the Word.

Of course, if you get sucked into the false beliefs, you might not be
able to do that. You need to know God and trust him for him to start to
help you.

Remember, the biblical order is:

Hear the Word,

Trust and Obey the Word,

and THEN God will prove himself to you.

>
>> There are also a number of things that don't have a "single"
>> interpretation that must be followed, but different people can
>> legitimately worship God acceptably in different ways.
>>
>>>
>>>> Yes, there are details that we do not need to (or in fact can not)
>>>> understand.
>>>>
>>>> But God expects us to do all that we have the power to do, then he
>>>> can do the rest.
>>>>
>>>> Intentionally neglecting what he says, puts you outside his Grace.
>>>>
>>>
>>>
>>
>

On 3/28/2024 9:49 PM, Richard Damon wrote:
> On 3/28/24 9:42 PM, olcott wrote:
>> On 3/28/2024 7:07 PM, Richard Damon wrote:
>>> On 3/28/24 10:53 AM, olcott wrote:
>>>> On 3/28/2024 6:59 AM, Richard Damon wrote:
>>>>> On 3/27/24 11:58 PM, olcott wrote:
>>>>>> On 3/27/2024 9:34 PM, Richard Damon wrote:
>>>>>>> On 3/27/24 10:07 PM, olcott wrote:
>>>>>>>> All of the different denominations having their differing views
>>>>>>>> proves that (at least) to the extent that they differ they are
>>>>>>>> incorrect.
>>>>>>>
>>>>>>> And the key is to actually STUDY to see what is the REAL truth
>>>>>>> behind all the variations, and what differences are important,
>>>>>>> and what are actually insubstantial.
>>>>>>>
>>>>>>> When you actually KNOW what the Bible says, and talk to others
>>>>>>> who also KNOW what the Bible says, you can discuss things with
>>>>>>> people even from very dofferent backgrounds, and find agreement.
>>>>>>>
>>>>>>> You get the big disagreements from people who don't actually know
>>>>>>> the Bible, but just the "Dogma" of their religious community.
>>>>>>> These are not really beleivers or possibly not even really
>>>>>>> "Christians" that Christ will take in the last day.
>>>>>>>
>>>>>>
>>>>>> It seems to me that all those things that do not pertain to
>>>>>> righteousness can be ignored.
>>>>>
>>>>> Righteousness is having a Right Relationship to God. Ignoring who
>>>>> he is makes that impossible.
>>>>>
>>>>>>
>>>>>> Things such as this:
>>>>>> Is the Godhead three different beings or one being taking three
>>>>>> forms?
>>>>>>
>>>>>
>>>>> But not correctly understanding who he is makes it impossible to
>>>>> have a right relationship to him.
>>>>>
>>>> Many churches differ on the trinity.
>>>
>>> Right, and just like you point out that many people may claim to be
>>> "Christians" but are not living a "Christian Life", many churches
>>> have also formed based on wrong ideas about the Bible.
>>>
>>> One of Satan's best methods is to get people to think they are "sage"
>>> in a Church, even thought ath Church isn't actually teaching them the
>>> truth.
>>>
>>
>> What is the infallible process to distinguish the difference?
>
> Testing the spirit against an honest interpretation of the Word.
>

How to you know the exactly correct figurative degree of interpretation?

> Of course, if you get sucked into the false beliefs, you might not be
> able to do that. You need to know God and trust him for him to start to
> help you.
>
> Remember, the biblical order is:
>
> Hear the Word,
>
> Trust and Obey the Word,
>
> and THEN God will prove himself to you.
>

--
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/28/24 11:03 PM, olcott wrote:
> On 3/28/2024 9:49 PM, Richard Damon wrote:
>> On 3/28/24 9:42 PM, olcott wrote:
>>> On 3/28/2024 7:07 PM, Richard Damon wrote:
>>>> On 3/28/24 10:53 AM, olcott wrote:
>>>>> On 3/28/2024 6:59 AM, Richard Damon wrote:
>>>>>> On 3/27/24 11:58 PM, olcott wrote:
>>>>>>> On 3/27/2024 9:34 PM, Richard Damon wrote:
>>>>>>>> On 3/27/24 10:07 PM, olcott wrote:
>>>>>>>>> All of the different denominations having their differing views
>>>>>>>>> proves that (at least) to the extent that they differ they are
>>>>>>>>> incorrect.
>>>>>>>>
>>>>>>>> And the key is to actually STUDY to see what is the REAL truth
>>>>>>>> behind all the variations, and what differences are important,
>>>>>>>> and what are actually insubstantial.
>>>>>>>>
>>>>>>>> When you actually KNOW what the Bible says, and talk to others
>>>>>>>> who also KNOW what the Bible says, you can discuss things with
>>>>>>>> people even from very dofferent backgrounds, and find agreement.
>>>>>>>>
>>>>>>>> You get the big disagreements from people who don't actually
>>>>>>>> know the Bible, but just the "Dogma" of their religious
>>>>>>>> community. These are not really beleivers or possibly not even
>>>>>>>> really "Christians" that Christ will take in the last day.
>>>>>>>>
>>>>>>>
>>>>>>> It seems to me that all those things that do not pertain to
>>>>>>> righteousness can be ignored.
>>>>>>
>>>>>> Righteousness is having a Right Relationship to God. Ignoring who
>>>>>> he is makes that impossible.
>>>>>>
>>>>>>>
>>>>>>> Things such as this:
>>>>>>> Is the Godhead three different beings or one being taking three
>>>>>>> forms?
>>>>>>>
>>>>>>
>>>>>> But not correctly understanding who he is makes it impossible to
>>>>>> have a right relationship to him.
>>>>>>
>>>>> Many churches differ on the trinity.
>>>>
>>>> Right, and just like you point out that many people may claim to be
>>>> "Christians" but are not living a "Christian Life", many churches
>>>> have also formed based on wrong ideas about the Bible.
>>>>
>>>> One of Satan's best methods is to get people to think they are
>>>> "sage" in a Church, even thought ath Church isn't actually teaching
>>>> them the truth.
>>>>
>>>
>>> What is the infallible process to distinguish the difference?
>>
>> Testing the spirit against an honest interpretation of the Word.
>>
>
> How to you know the exactly correct figurative degree of interpretation?

I trust God to let me know.

When you let the TRUE God guide you, he will lead you into truth.

Of course, the hard part is initially finding the right path to be on.

He leaves enough hints to find it if you are willing to honestly look,
but leaves open the option to not see if you don't want.

>
>> Of course, if you get sucked into the false beliefs, you might not be
>> able to do that. You need to know God and trust him for him to start
>> to help you.
>>
>> Remember, the biblical order is:
>>
>> Hear the Word,
>>
>> Trust and Obey the Word,
>>
>> and THEN God will prove himself to you.
>>
>
>

On 3/29/2024 8:13 AM, Richard Damon wrote:
> On 3/28/24 11:03 PM, olcott wrote:
>> On 3/28/2024 9:49 PM, Richard Damon wrote:
>>> On 3/28/24 9:42 PM, olcott wrote:
>>>> On 3/28/2024 7:07 PM, Richard Damon wrote:
>>>>> On 3/28/24 10:53 AM, olcott wrote:
>>>>>> On 3/28/2024 6:59 AM, Richard Damon wrote:
>>>>>>> On 3/27/24 11:58 PM, olcott wrote:
>>>>>>>> On 3/27/2024 9:34 PM, Richard Damon wrote:
>>>>>>>>> On 3/27/24 10:07 PM, olcott wrote:
>>>>>>>>>> All of the different denominations having their differing views
>>>>>>>>>> proves that (at least) to the extent that they differ they are
>>>>>>>>>> incorrect.
>>>>>>>>>
>>>>>>>>> And the key is to actually STUDY to see what is the REAL truth
>>>>>>>>> behind all the variations, and what differences are important,
>>>>>>>>> and what are actually insubstantial.
>>>>>>>>>
>>>>>>>>> When you actually KNOW what the Bible says, and talk to others
>>>>>>>>> who also KNOW what the Bible says, you can discuss things with
>>>>>>>>> people even from very dofferent backgrounds, and find agreement.
>>>>>>>>>
>>>>>>>>> You get the big disagreements from people who don't actually
>>>>>>>>> know the Bible, but just the "Dogma" of their religious
>>>>>>>>> community. These are not really beleivers or possibly not even
>>>>>>>>> really "Christians" that Christ will take in the last day.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It seems to me that all those things that do not pertain to
>>>>>>>> righteousness can be ignored.
>>>>>>>
>>>>>>> Righteousness is having a Right Relationship to God. Ignoring who
>>>>>>> he is makes that impossible.
>>>>>>>
>>>>>>>>
>>>>>>>> Things such as this:
>>>>>>>> Is the Godhead three different beings or one being taking three
>>>>>>>> forms?
>>>>>>>>
>>>>>>>
>>>>>>> But not correctly understanding who he is makes it impossible to
>>>>>>> have a right relationship to him.
>>>>>>>
>>>>>> Many churches differ on the trinity.
>>>>>
>>>>> Right, and just like you point out that many people may claim to be
>>>>> "Christians" but are not living a "Christian Life", many churches
>>>>> have also formed based on wrong ideas about the Bible.
>>>>>
>>>>> One of Satan's best methods is to get people to think they are
>>>>> "sage" in a Church, even thought ath Church isn't actually teaching
>>>>> them the truth.
>>>>>
>>>>
>>>> What is the infallible process to distinguish the difference?
>>>
>>> Testing the spirit against an honest interpretation of the Word.
>>>
>>
>> How to you know the exactly correct figurative degree of interpretation?
>
> I trust God to let me know.
>
> When you let the TRUE God guide you, he will lead you into truth.
>
> Of course, the hard part is initially finding the right path to be on.
>
> He leaves enough hints to find it if you are willing to honestly look,
> but leaves open the option to not see if you don't want.
>

Christ said know them by their fruits.
https://ethicsunwrapped.utexas.edu/glossary/consequentialism

I have been a consequentialist (like Christ) since I first
studied the truth behind religion in 1992. I did not know its
name until 2016 when a Muslim friend of mine that I prayed
with told me about this from a college course he was taking.

I have always rejected the "do as you are told" form of morality
that told Abraham to kill is son Isaac. My measure has always
been benevolent outcomes are on the correct side of righteousness
and malevolent outcomes are on the wrong side.

>>
>>> Of course, if you get sucked into the false beliefs, you might not be
>>> able to do that. You need to know God and trust him for him to start
>>> to help you.
>>>
>>> Remember, the biblical order is:
>>>
>>> Hear the Word,
>>>
>>> Trust and Obey the Word,
>>>
>>> and THEN God will prove himself to you.
>>>
>>
>>
>

--
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/29/24 10:56 AM, olcott wrote:
> On 3/29/2024 8:13 AM, Richard Damon wrote:
>> On 3/28/24 11:03 PM, olcott wrote:
>>> On 3/28/2024 9:49 PM, Richard Damon wrote:
>>>> On 3/28/24 9:42 PM, olcott wrote:
>>>>> On 3/28/2024 7:07 PM, Richard Damon wrote:
>>>>>> On 3/28/24 10:53 AM, olcott wrote:
>>>>>>> On 3/28/2024 6:59 AM, Richard Damon wrote:
>>>>>>>> On 3/27/24 11:58 PM, olcott wrote:
>>>>>>>>> On 3/27/2024 9:34 PM, Richard Damon wrote:
>>>>>>>>>> On 3/27/24 10:07 PM, olcott wrote:
>>>>>>>>>>> All of the different denominations having their differing views
>>>>>>>>>>> proves that (at least) to the extent that they differ they are
>>>>>>>>>>> incorrect.
>>>>>>>>>>
>>>>>>>>>> And the key is to actually STUDY to see what is the REAL truth
>>>>>>>>>> behind all the variations, and what differences are important,
>>>>>>>>>> and what are actually insubstantial.
>>>>>>>>>>
>>>>>>>>>> When you actually KNOW what the Bible says, and talk to others
>>>>>>>>>> who also KNOW what the Bible says, you can discuss things with
>>>>>>>>>> people even from very dofferent backgrounds, and find agreement.
>>>>>>>>>>
>>>>>>>>>> You get the big disagreements from people who don't actually
>>>>>>>>>> know the Bible, but just the "Dogma" of their religious
>>>>>>>>>> community. These are not really beleivers or possibly not even
>>>>>>>>>> really "Christians" that Christ will take in the last day.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It seems to me that all those things that do not pertain to
>>>>>>>>> righteousness can be ignored.
>>>>>>>>
>>>>>>>> Righteousness is having a Right Relationship to God. Ignoring
>>>>>>>> who he is makes that impossible.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Things such as this:
>>>>>>>>> Is the Godhead three different beings or one being taking three
>>>>>>>>> forms?
>>>>>>>>>
>>>>>>>>
>>>>>>>> But not correctly understanding who he is makes it impossible to
>>>>>>>> have a right relationship to him.
>>>>>>>>
>>>>>>> Many churches differ on the trinity.
>>>>>>
>>>>>> Right, and just like you point out that many people may claim to
>>>>>> be "Christians" but are not living a "Christian Life", many
>>>>>> churches have also formed based on wrong ideas about the Bible.
>>>>>>
>>>>>> One of Satan's best methods is to get people to think they are
>>>>>> "sage" in a Church, even thought ath Church isn't actually
>>>>>> teaching them the truth.
>>>>>>
>>>>>
>>>>> What is the infallible process to distinguish the difference?
>>>>
>>>> Testing the spirit against an honest interpretation of the Word.
>>>>
>>>
>>> How to you know the exactly correct figurative degree of interpretation?
>>
>> I trust God to let me know.
>>
>> When you let the TRUE God guide you, he will lead you into truth.
>>
>> Of course, the hard part is initially finding the right path to be on.
>>
>> He leaves enough hints to find it if you are willing to honestly look,
>> but leaves open the option to not see if you don't want.
>>
>
> Christ said know them by their fruits.
> https://ethicsunwrapped.utexas.edu/glossary/consequentialism

Yep, all sorts of ways of twisting a fundamental statement incorrectly?

>
> I have been a consequentialist (like Christ) since I first
> studied the truth behind religion in 1992. I did not know its
> name until 2016 when a Muslim friend of mine that I prayed
> with told me about this from a college course he was taking.

So, what are your "Fruits"?

How do they align with the Fruits the bible tells us we should have?

Is your endless repetion of your same words the way you show "Self-Control"?

>
> I have always rejected the "do as you are told" form of morality
> that told Abraham to kill is son Isaac. My measure has always
> been benevolent outcomes are on the correct side of righteousness
> and malevolent outcomes are on the wrong side.

Which means that you are rejecting the authority of God, and thus his
Grace, and will need to past the test on your own (admittedly fallible)
power.

>
>>>
>>>> Of course, if you get sucked into the false beliefs, you might not
>>>> be able to do that. You need to know God and trust him for him to
>>>> start to help you.
>>>>
>>>> Remember, the biblical order is:
>>>>
>>>> Hear the Word,
>>>>
>>>> Trust and Obey the Word,
>>>>
>>>> and THEN God will prove himself to you.
>>>>
>>>
>>>
>>
>